<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE RankNTypes, BangPatterns, FlexibleContexts, Strict #-}</span><span>
</span><span id="line-2"></span><span>
</span><span id="line-3"></span><span class="hs-comment">{- |
  Module      :  Dominators
  Copyright   :  (c) Matt Morrow 2009
  License     :  BSD3
  Maintainer  :  &lt;morrow@moonpatio.com&gt;
  Stability   :  experimental
  Portability :  portable

  Taken from the dom-lt package.

  The Lengauer-Tarjan graph dominators algorithm.

    \[1\] Lengauer, Tarjan,
      /A Fast Algorithm for Finding Dominators in a Flowgraph/, 1979.

    \[2\] Muchnick,
      /Advanced Compiler Design and Implementation/, 1997.

    \[3\] Brisk, Sarrafzadeh,
      /Interference Graphs for Procedures in Static Single/
      /Information Form are Interval Graphs/, 2007.

  Originally taken from the dom-lt package.
-}</span><span>
</span><span id="line-27"></span><span>
</span><span id="line-28"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.CmmToAsm.CFG.Dominators</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-29"></span><span>   </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Path"><span class="hs-identifier">Path</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Edge"><span class="hs-identifier">Edge</span></a></span><span>
</span><span id="line-30"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier">Graph</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier">Rooted</span></a></span><span>
</span><span id="line-31"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#idom"><span class="hs-identifier">idom</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ipdom"><span class="hs-identifier">ipdom</span></a></span><span>
</span><span id="line-32"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#domTree"><span class="hs-identifier">domTree</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pdomTree"><span class="hs-identifier">pdomTree</span></a></span><span>
</span><span id="line-33"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#dom"><span class="hs-identifier">dom</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pdom"><span class="hs-identifier">pdom</span></a></span><span>
</span><span id="line-34"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pddfs"><span class="hs-identifier">pddfs</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#rpddfs"><span class="hs-identifier">rpddfs</span></a></span><span>
</span><span id="line-35"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fromAdj"><span class="hs-identifier">fromAdj</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEdges"><span class="hs-identifier">fromEdges</span></a></span><span>
</span><span id="line-36"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#toAdj"><span class="hs-identifier">toAdj</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#toEdges"><span class="hs-identifier">toEdges</span></a></span><span>
</span><span id="line-37"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#asTree"><span class="hs-identifier">asTree</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#asGraph"><span class="hs-identifier">asGraph</span></a></span><span>
</span><span id="line-38"></span><span>  </span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#parents"><span class="hs-identifier">parents</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestors"><span class="hs-identifier">ancestors</span></a></span><span>
</span><span id="line-39"></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-40"></span><span>
</span><span id="line-41"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Prelude.html"><span class="hs-identifier">GHC.Prelude</span></a></span><span>
</span><span id="line-42"></span><span>
</span><span id="line-43"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Bifunctor.html#"><span class="hs-identifier">Data.Bifunctor</span></a></span><span>
</span><span id="line-44"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Tuple.html#"><span class="hs-identifier">Data.Tuple</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Tuple.html#swap"><span class="hs-identifier">swap</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#"><span class="hs-identifier">Data.Tree</span></a></span><span>
</span><span id="line-47"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.html#"><span class="hs-identifier">Data.IntMap</span></a></span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier">IntMap</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-48"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.html#"><span class="hs-identifier">Data.IntSet</span></a></span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier">IntSet</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Strict.html#"><span class="hs-identifier">Data.IntMap.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">IM</span></span><span>
</span><span id="line-50"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.html#"><span class="hs-identifier">Data.IntSet</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">IS</span></span><span>
</span><span id="line-51"></span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span>
</span><span id="line-53"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.ST.Strict.html#"><span class="hs-identifier">Control.Monad.ST.Strict</span></a></span><span>
</span><span id="line-54"></span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.ST.html#"><span class="hs-identifier">Data.Array.ST</span></a></span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#"><span class="hs-identifier">Data.Array.Base</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#%21"><span class="hs-operator">(!)</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-57"></span><span>  </span><span class="hs-comment">-- (unsafeNewArray_</span><span>
</span><span id="line-58"></span><span>  </span><span class="hs-comment">-- ,unsafeWrite,unsafeRead</span><span>
</span><span id="line-59"></span><span>  </span><span class="hs-comment">-- ,readArray,writeArray)</span><span>
</span><span id="line-60"></span><span>
</span><span id="line-61"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Utils.Misc.html"><span class="hs-identifier">GHC.Utils.Misc</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Misc.html#debugIsOn"><span class="hs-identifier">debugIsOn</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-64"></span><span>
</span><span id="line-65"></span><span class="hs-keyword">type</span><span> </span><span id="Node"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-var">Node</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-66"></span><span class="hs-keyword">type</span><span> </span><span id="Path"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Path"><span class="hs-identifier hs-var">Path</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-67"></span><span class="hs-keyword">type</span><span> </span><span id="Edge"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Edge"><span class="hs-identifier hs-var">Edge</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-68"></span><span class="hs-keyword">type</span><span> </span><span id="Graph"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-var">Graph</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span>
</span><span id="line-69"></span><span class="hs-keyword">type</span><span> </span><span id="Rooted"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-var">Rooted</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-70"></span><span>
</span><span id="line-71"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-72"></span><span>
</span><span id="line-73"></span><span class="hs-comment">-- | /Dominators/.</span><span>
</span><span id="line-74"></span><span class="hs-comment">-- Complexity as for @idom@</span><span>
</span><span id="line-75"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#dom"><span class="hs-identifier hs-type">dom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Path"><span class="hs-identifier hs-type">Path</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-76"></span><span id="dom"><span class="annot"><span class="annottext">dom :: Rooted -&gt; [(Int, Path)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dom"><span class="hs-identifier hs-var hs-var">dom</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Tree Int -&gt; [(Int, Path)]
forall a. Tree a -&gt; [(a, [a])]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestors"><span class="hs-identifier hs-var">ancestors</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree Int -&gt; [(Int, Path)])
-&gt; (Rooted -&gt; Tree Int) -&gt; Rooted -&gt; [(Int, Path)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domTree"><span class="hs-identifier hs-var">domTree</span></a></span><span>
</span><span id="line-77"></span><span>
</span><span id="line-78"></span><span class="hs-comment">-- | /Post-dominators/.</span><span>
</span><span id="line-79"></span><span class="hs-comment">-- Complexity as for @idom@.</span><span>
</span><span id="line-80"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pdom"><span class="hs-identifier hs-type">pdom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Path"><span class="hs-identifier hs-type">Path</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-81"></span><span id="pdom"><span class="annot"><span class="annottext">pdom :: Rooted -&gt; [(Int, Path)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pdom"><span class="hs-identifier hs-var hs-var">pdom</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Tree Int -&gt; [(Int, Path)]
forall a. Tree a -&gt; [(a, [a])]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestors"><span class="hs-identifier hs-var">ancestors</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree Int -&gt; [(Int, Path)])
-&gt; (Rooted -&gt; Tree Int) -&gt; Rooted -&gt; [(Int, Path)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pdomTree"><span class="hs-identifier hs-var">pdomTree</span></a></span><span>
</span><span id="line-82"></span><span>
</span><span id="line-83"></span><span class="hs-comment">-- | /Dominator tree/.</span><span>
</span><span id="line-84"></span><span class="hs-comment">-- Complexity as for @idom@.</span><span>
</span><span id="line-85"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#domTree"><span class="hs-identifier hs-type">domTree</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-86"></span><span id="domTree"><span class="annot"><span class="annottext">domTree :: Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domTree"><span class="hs-identifier hs-var hs-var">domTree</span></a></span></span><span> </span><span id="local-6989586621680781501"><span class="annot"><span class="annottext">a :: Rooted
</span><a href="#local-6989586621680781501"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span id="local-6989586621680781500"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781500"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-87"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781497"><span class="annot"><span class="annottext">is :: [(Int, Int)]
</span><a href="#local-6989586621680781497"><span class="hs-identifier hs-var hs-var">is</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((Int, Int) -&gt; Bool) -&gt; [(Int, Int)] -&gt; [(Int, Int)]
forall a. (a -&gt; Bool) -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#filter"><span class="hs-identifier hs-var">filter</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781500"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span class="annot"><span class="annottext">(Int -&gt; Bool) -&gt; ((Int, Int) -&gt; Int) -&gt; (Int, Int) -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span class="annot"><span class="annottext">(Int, Int) -&gt; Int
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rooted -&gt; [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#idom"><span class="hs-identifier hs-var">idom</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781501"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-88"></span><span>      </span><span id="local-6989586621680781494"><span class="annot"><span class="annottext">tg :: IntMap IntSet
</span><a href="#local-6989586621680781494"><span class="hs-identifier hs-var hs-var">tg</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, Int)] -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEdges"><span class="hs-identifier hs-var">fromEdges</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">((Int, Int) -&gt; (Int, Int)) -&gt; [(Int, Int)] -&gt; [(Int, Int)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; (Int, Int)
forall a b. (a, b) -&gt; (b, a)
</span><a href="../../base/src/Data.Tuple.html#swap"><span class="hs-identifier hs-var">swap</span></a></span><span> </span><span class="annot"><span class="annottext">[(Int, Int)]
</span><a href="#local-6989586621680781497"><span class="hs-identifier hs-var">is</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-89"></span><span>  </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#asTree"><span class="hs-identifier hs-var">asTree</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781500"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781494"><span class="hs-identifier hs-var">tg</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-90"></span><span>
</span><span id="line-91"></span><span class="hs-comment">-- | /Post-dominator tree/.</span><span>
</span><span id="line-92"></span><span class="hs-comment">-- Complexity as for @idom@.</span><span>
</span><span id="line-93"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pdomTree"><span class="hs-identifier hs-type">pdomTree</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-94"></span><span id="pdomTree"><span class="annot"><span class="annottext">pdomTree :: Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pdomTree"><span class="hs-identifier hs-var hs-var">pdomTree</span></a></span></span><span> </span><span id="local-6989586621680781493"><span class="annot"><span class="annottext">a :: Rooted
</span><a href="#local-6989586621680781493"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span id="local-6989586621680781492"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781492"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-95"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781490"><span class="annot"><span class="annottext">is :: [(Int, Int)]
</span><a href="#local-6989586621680781490"><span class="hs-identifier hs-var hs-var">is</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((Int, Int) -&gt; Bool) -&gt; [(Int, Int)] -&gt; [(Int, Int)]
forall a. (a -&gt; Bool) -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#filter"><span class="hs-identifier hs-var">filter</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781492"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span class="annot"><span class="annottext">(Int -&gt; Bool) -&gt; ((Int, Int) -&gt; Int) -&gt; (Int, Int) -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span class="annot"><span class="annottext">(Int, Int) -&gt; Int
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rooted -&gt; [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ipdom"><span class="hs-identifier hs-var">ipdom</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781493"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-96"></span><span>      </span><span id="local-6989586621680781488"><span class="annot"><span class="annottext">tg :: IntMap IntSet
</span><a href="#local-6989586621680781488"><span class="hs-identifier hs-var hs-var">tg</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, Int)] -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEdges"><span class="hs-identifier hs-var">fromEdges</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">((Int, Int) -&gt; (Int, Int)) -&gt; [(Int, Int)] -&gt; [(Int, Int)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; (Int, Int)
forall a b. (a, b) -&gt; (b, a)
</span><a href="../../base/src/Data.Tuple.html#swap"><span class="hs-identifier hs-var">swap</span></a></span><span> </span><span class="annot"><span class="annottext">[(Int, Int)]
</span><a href="#local-6989586621680781490"><span class="hs-identifier hs-var">is</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-97"></span><span>  </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#asTree"><span class="hs-identifier hs-var">asTree</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781492"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781488"><span class="hs-identifier hs-var">tg</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-98"></span><span>
</span><span id="line-99"></span><span class="hs-comment">-- | /Immediate dominators/.</span><span>
</span><span id="line-100"></span><span class="hs-comment">-- /O(|E|*alpha(|E|,|V|))/, where /alpha(m,n)/ is</span><span>
</span><span id="line-101"></span><span class="hs-comment">-- \&quot;a functional inverse of Ackermann's function\&quot;.</span><span>
</span><span id="line-102"></span><span class="hs-comment">--</span><span>
</span><span id="line-103"></span><span class="hs-comment">-- This Complexity bound assumes /O(1)/ indexing. Since we're</span><span>
</span><span id="line-104"></span><span class="hs-comment">-- using @IntMap@, it has an additional /lg |V|/ factor</span><span>
</span><span id="line-105"></span><span class="hs-comment">-- somewhere in there. I'm not sure where.</span><span>
</span><span id="line-106"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#idom"><span class="hs-identifier hs-type">idom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-107"></span><span id="idom"><span class="annot"><span class="annottext">idom :: Rooted -&gt; [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#idom"><span class="hs-identifier hs-var hs-var">idom</span></a></span></span><span> </span><span id="local-6989586621680781487"><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781487"><span class="hs-identifier hs-var">rg</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [(Int, Int)]) -&gt; [(Int, Int)]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">S s (Env s) [(Int, Int)] -&gt; Env s -&gt; ST s [(Int, Int)]
forall z s a. S z s a -&gt; s -&gt; ST z a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#evalS"><span class="hs-identifier hs-var">evalS</span></a></span><span> </span><span class="annot"><span class="annottext">S s (Env s) [(Int, Int)]
forall s. Dom s [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#idomM"><span class="hs-identifier hs-var">idomM</span></a></span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; ST s [(Int, Int)]) -&gt; ST s (Env s) -&gt; ST s [(Int, Int)]
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; ST s (Env s)
forall s. Rooted -&gt; ST s (Env s)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#initEnv"><span class="hs-identifier hs-var">initEnv</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rooted -&gt; Rooted
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pruneReach"><span class="hs-identifier hs-var">pruneReach</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781487"><span class="hs-identifier hs-var">rg</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-108"></span><span>
</span><span id="line-109"></span><span class="hs-comment">-- | /Immediate post-dominators/.</span><span>
</span><span id="line-110"></span><span class="hs-comment">-- Complexity as for @idom@.</span><span>
</span><span id="line-111"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ipdom"><span class="hs-identifier hs-type">ipdom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-112"></span><span id="ipdom"><span class="annot"><span class="annottext">ipdom :: Rooted -&gt; [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ipdom"><span class="hs-identifier hs-var hs-var">ipdom</span></a></span></span><span> </span><span id="local-6989586621680781478"><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781478"><span class="hs-identifier hs-var">rg</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall s. ST s [(Int, Int)]) -&gt; [(Int, Int)]
forall a. (forall s. ST s a) -&gt; a
</span><a href="../../base/src/GHC.ST.html#runST"><span class="hs-identifier hs-var">runST</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">S s (Env s) [(Int, Int)] -&gt; Env s -&gt; ST s [(Int, Int)]
forall z s a. S z s a -&gt; s -&gt; ST z a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#evalS"><span class="hs-identifier hs-var">evalS</span></a></span><span> </span><span class="annot"><span class="annottext">S s (Env s) [(Int, Int)]
forall s. Dom s [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#idomM"><span class="hs-identifier hs-var">idomM</span></a></span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; ST s [(Int, Int)]) -&gt; ST s (Env s) -&gt; ST s [(Int, Int)]
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; ST s (Env s)
forall s. Rooted -&gt; ST s (Env s)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#initEnv"><span class="hs-identifier hs-var">initEnv</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Rooted -&gt; Rooted
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pruneReach"><span class="hs-identifier hs-var">pruneReach</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; IntMap IntSet) -&gt; Rooted -&gt; Rooted
forall (p :: * -&gt; * -&gt; *) b c a.
Bifunctor p =&gt;
(b -&gt; c) -&gt; p a b -&gt; p a c
</span><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-identifier hs-var">second</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predG"><span class="hs-identifier hs-var">predG</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted
</span><a href="#local-6989586621680781478"><span class="hs-identifier hs-var">rg</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-113"></span><span>
</span><span id="line-114"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-115"></span><span>
</span><span id="line-116"></span><span class="hs-comment">-- | /Post-dominated depth-first search/.</span><span>
</span><span id="line-117"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pddfs"><span class="hs-identifier hs-type">pddfs</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-118"></span><span id="pddfs"><span class="annot"><span class="annottext">pddfs :: Rooted -&gt; Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pddfs"><span class="hs-identifier hs-var hs-var">pddfs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Path -&gt; Path
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#reverse"><span class="hs-identifier hs-var">reverse</span></a></span><span> </span><span class="annot"><span class="annottext">(Path -&gt; Path) -&gt; (Rooted -&gt; Path) -&gt; Rooted -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rpddfs"><span class="hs-identifier hs-var">rpddfs</span></a></span><span>
</span><span id="line-119"></span><span>
</span><span id="line-120"></span><span class="hs-comment">-- | /Reverse post-dominated depth-first search/.</span><span>
</span><span id="line-121"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#rpddfs"><span class="hs-identifier hs-type">rpddfs</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-122"></span><span id="rpddfs"><span class="annot"><span class="annottext">rpddfs :: Rooted -&gt; Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rpddfs"><span class="hs-identifier hs-var hs-var">rpddfs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Path] -&gt; Path
forall (t :: * -&gt; *) a. Foldable t =&gt; t [a] -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#concat"><span class="hs-identifier hs-var">concat</span></a></span><span> </span><span class="annot"><span class="annottext">([Path] -&gt; Path) -&gt; (Rooted -&gt; [Path]) -&gt; Rooted -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Tree Int -&gt; [Path]
forall a. Tree a -&gt; [[a]]
</span><a href="../../containers/src/Data.Tree.html#levels"><span class="hs-identifier hs-var">levels</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree Int -&gt; [Path]) -&gt; (Rooted -&gt; Tree Int) -&gt; Rooted -&gt; [Path]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pdomTree"><span class="hs-identifier hs-var">pdomTree</span></a></span><span>
</span><span id="line-123"></span><span>
</span><span id="line-124"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-125"></span><span>
</span><span id="line-126"></span><span class="hs-keyword">type</span><span> </span><span id="Dom"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-var">Dom</span></a></span></span><span> </span><span id="local-6989586621680781470"><span class="annot"><a href="#local-6989586621680781470"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span id="local-6989586621680781469"><span class="annot"><a href="#local-6989586621680781469"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781470"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Env"><span class="hs-identifier hs-type">Env</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781470"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781469"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-127"></span><span class="hs-keyword">type</span><span> </span><span id="NodeSet"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeSet"><span class="hs-identifier hs-var">NodeSet</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span>
</span><span id="line-128"></span><span class="hs-keyword">type</span><span> </span><span id="NodeMap"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-var">NodeMap</span></a></span></span><span> </span><span id="local-6989586621680781467"><span class="annot"><a href="#local-6989586621680781467"><span class="hs-identifier hs-type">a</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781467"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-129"></span><span class="hs-keyword">data</span><span> </span><span id="Env"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Env"><span class="hs-identifier hs-var">Env</span></a></span></span><span> </span><span id="local-6989586621680781792"><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Env"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Env"><span class="hs-identifier hs-var">Env</span></a></span></span><span>
</span><span id="line-130"></span><span>  </span><span class="hs-special">{</span><span id="succE"><span class="annot"><span class="annottext">forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#succE"><span class="hs-identifier hs-var hs-var">succE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-131"></span><span>  </span><span class="hs-special">,</span><span id="predE"><span class="annot"><span class="annottext">forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predE"><span class="hs-identifier hs-var hs-var">predE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-132"></span><span>  </span><span class="hs-special">,</span><span id="bucketE"><span class="annot"><span class="annottext">forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketE"><span class="hs-identifier hs-var hs-var">bucketE</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-133"></span><span>  </span><span class="hs-special">,</span><span id="dfsE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsE"><span class="hs-identifier hs-var hs-var">dfsE</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-134"></span><span>  </span><span class="hs-special">,</span><span id="zeroE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroE"><span class="hs-identifier hs-var hs-var">zeroE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-135"></span><span>  </span><span class="hs-special">,</span><span id="rootE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootE"><span class="hs-identifier hs-var hs-var">rootE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-136"></span><span>  </span><span class="hs-special">,</span><span id="labelE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-137"></span><span>  </span><span class="hs-special">,</span><span id="parentE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentE"><span class="hs-identifier hs-var hs-var">parentE</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-138"></span><span>  </span><span class="hs-special">,</span><span id="ancestorE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-139"></span><span>  </span><span class="hs-special">,</span><span id="childE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childE"><span class="hs-identifier hs-var hs-var">childE</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-140"></span><span>  </span><span class="hs-special">,</span><span id="ndfsE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsE"><span class="hs-identifier hs-var hs-var">ndfsE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-141"></span><span>  </span><span class="hs-special">,</span><span id="dfnE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfnE"><span class="hs-identifier hs-var hs-var">dfnE</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span>
</span><span id="line-142"></span><span>  </span><span class="hs-special">,</span><span id="sdnoE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoE"><span class="hs-identifier hs-var hs-var">sdnoE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span>
</span><span id="line-143"></span><span>  </span><span class="hs-special">,</span><span id="sizeE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeE"><span class="hs-identifier hs-var hs-var">sizeE</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span>
</span><span id="line-144"></span><span>  </span><span class="hs-special">,</span><span id="domE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var hs-var">domE</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-145"></span><span>  </span><span class="hs-special">,</span><span id="rnE"><span class="annot"><span class="annottext">forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rnE"><span class="hs-identifier hs-var hs-var">rnE</span></a></span></span><span>        </span><span class="hs-glyph">::</span><span> </span><span class="hs-pragma">{-# UNPACK</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781792"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-146"></span><span>
</span><span id="line-147"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-148"></span><span>
</span><span id="line-149"></span><span id="local-6989586621680781807"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#idomM"><span class="hs-identifier hs-type">idomM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781807"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span></span><span>
</span><span id="line-150"></span><span id="idomM"><span class="annot"><span class="annottext">idomM :: forall s. Dom s [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#idomM"><span class="hs-identifier hs-var hs-var">idomM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-151"></span><span>  </span><span class="annot"><span class="annottext">Int -&gt; Dom s ()
forall s. Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsDom"><span class="hs-identifier hs-var">dfsDom</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Dom s ()) -&gt; S s (Env s) Int -&gt; Dom s ()
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">S s (Env s) Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootM"><span class="hs-identifier hs-var">rootM</span></a></span><span>
</span><span id="line-152"></span><span>  </span><span id="local-6989586621680781398"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781398"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Int) -&gt; S s (Env s) Int
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Int
forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsE"><span class="hs-identifier hs-var hs-var">dfsE</span></a></span><span>
</span><span id="line-153"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; Dom s ()) -&gt; Dom s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781398"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781398"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781395"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781395"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-154"></span><span>    </span><span id="local-6989586621680781394"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-var">ndfsM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781395"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-155"></span><span>    </span><span id="local-6989586621680781392"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781392"><span class="hs-identifier hs-var">sw</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-156"></span><span>    </span><span id="local-6989586621680781390"><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781390"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Path
forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predsM"><span class="hs-identifier hs-var">predsM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-157"></span><span>    </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; Dom s ()) -&gt; Dom s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781390"><span class="hs-identifier hs-var">ps</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781388"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781388"><span class="hs-identifier hs-var">v</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-158"></span><span>      </span><span id="local-6989586621680781387"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781387"><span class="hs-identifier hs-var">u</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#eval"><span class="hs-identifier hs-var">eval</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781388"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-159"></span><span>      </span><span id="local-6989586621680781385"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781385"><span class="hs-identifier hs-var">su</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781387"><span class="hs-identifier hs-var">u</span></a></span><span>
</span><span id="line-160"></span><span>      </span><span class="annot"><span class="annottext">Bool -&gt; Dom s () -&gt; Dom s ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781385"><span class="hs-identifier hs-var">su</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781392"><span class="hs-identifier hs-var">sw</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-161"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoE"><span class="hs-identifier hs-var hs-var">sdnoE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781385"><span class="hs-identifier hs-var">su</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-162"></span><span>    </span><span id="local-6989586621680781381"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781381"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-var">ndfsM</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; S s (Env s) Int) -&gt; S s (Env s) Int -&gt; S s (Env s) Int
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-163"></span><span>    </span><span class="annot"><span class="annottext">(Env s -&gt; Env s) -&gt; Dom s ()
forall s z. (s -&gt; s) -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#modify"><span class="hs-identifier hs-var">modify</span></a></span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781379"><span class="annot"><span class="annottext">Env s
</span><a href="#local-6989586621680781379"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-glyph">-&gt;</span><span class="annot"><span class="annottext">Env s
</span><a href="#local-6989586621680781379"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">{</span><span class="annot"><span class="annottext">bucketE :: IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketE"><span class="hs-identifier hs-var">bucketE</span></a></span><span class="hs-glyph">=</span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet) -&gt; Int -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a. (a -&gt; a) -&gt; Int -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#adjust"><span class="hs-identifier hs-var">IM.adjust</span></a></span><span>
</span><span id="line-164"></span><span>                      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span class="annot"><span class="annottext">Int -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#insert"><span class="hs-operator hs-var">`IS.insert`</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-165"></span><span>                      </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781381"><span class="hs-identifier hs-var">z</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Env s -&gt; IntMap IntSet
forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketE"><span class="hs-identifier hs-var hs-var">bucketE</span></a></span><span> </span><span class="annot"><span class="annottext">Env s
</span><a href="#local-6989586621680781379"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-166"></span><span>    </span><span id="local-6989586621680781376"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781376"><span class="hs-identifier hs-var">pw</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentM"><span class="hs-identifier hs-var">parentM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-167"></span><span>    </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Dom s ()
forall s. Int -&gt; Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#link"><span class="hs-identifier hs-var">link</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781376"><span class="hs-identifier hs-var">pw</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781394"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-168"></span><span>    </span><span id="local-6989586621680781373"><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781373"><span class="hs-identifier hs-var">bps</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Path
forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketM"><span class="hs-identifier hs-var">bucketM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781376"><span class="hs-identifier hs-var">pw</span></a></span><span>
</span><span id="line-169"></span><span>    </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; Dom s ()) -&gt; Dom s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781373"><span class="hs-identifier hs-var">bps</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781371"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781371"><span class="hs-identifier hs-var">v</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-170"></span><span>      </span><span id="local-6989586621680781370"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781370"><span class="hs-identifier hs-var">u</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#eval"><span class="hs-identifier hs-var">eval</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781371"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-171"></span><span>      </span><span id="local-6989586621680781369"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781369"><span class="hs-identifier hs-var">su</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781370"><span class="hs-identifier hs-var">u</span></a></span><span>
</span><span id="line-172"></span><span>      </span><span id="local-6989586621680781368"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781368"><span class="hs-identifier hs-var">sv</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781371"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-173"></span><span>      </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781366"><span class="annot"><span class="annottext">dv :: Int
</span><a href="#local-6989586621680781366"><span class="hs-identifier hs-var hs-var">dv</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781369"><span class="hs-identifier hs-var">su</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781368"><span class="hs-identifier hs-var">sv</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-174"></span><span>                </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781370"><span class="hs-identifier hs-var">u</span></a></span><span>
</span><span id="line-175"></span><span>                </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781376"><span class="hs-identifier hs-var">pw</span></a></span><span>
</span><span id="line-176"></span><span>      </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var hs-var">domE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781371"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781366"><span class="hs-identifier hs-var">dv</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-177"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; Dom s ()) -&gt; Dom s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781398"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781365"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781365"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-178"></span><span>    </span><span id="local-6989586621680781364"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781364"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-var">ndfsM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781365"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-179"></span><span>    </span><span id="local-6989586621680781363"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781363"><span class="hs-identifier hs-var">j</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781364"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span id="local-6989586621680781362"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781362"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-var">ndfsM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781363"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-181"></span><span>    </span><span id="local-6989586621680781361"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781361"><span class="hs-identifier hs-var">dw</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domM"><span class="hs-identifier hs-var">domM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781364"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-182"></span><span>    </span><span class="annot"><span class="annottext">Bool -&gt; Dom s () -&gt; Dom s ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781361"><span class="hs-identifier hs-var">dw</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781362"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-183"></span><span>      </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680781359"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781359"><span class="hs-identifier hs-var">ddw</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domM"><span class="hs-identifier hs-var">domM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781361"><span class="hs-identifier hs-var">dw</span></a></span><span>
</span><span id="line-184"></span><span>          </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var hs-var">domE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781364"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781359"><span class="hs-identifier hs-var">ddw</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-185"></span><span>  </span><span class="annot"><span class="annottext">Dom s [(Int, Int)]
forall s. Dom s [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEnv"><span class="hs-identifier hs-var">fromEnv</span></a></span><span>
</span><span id="line-186"></span><span>
</span><span id="line-187"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span id="local-6989586621680781357"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#eval"><span class="hs-identifier hs-type">eval</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781357"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-190"></span><span id="eval"><span class="annot"><span class="annottext">eval :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#eval"><span class="hs-identifier hs-var hs-var">eval</span></a></span></span><span> </span><span id="local-6989586621680781344"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-191"></span><span>  </span><span id="local-6989586621680781343"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781343"><span class="hs-identifier hs-var">n0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-var">zeroM</span></a></span><span>
</span><span id="line-192"></span><span>  </span><span id="local-6989586621680781341"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781341"><span class="hs-identifier hs-var">a</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-193"></span><span>  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781341"><span class="hs-identifier hs-var">a</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781343"><span class="hs-identifier hs-var">n0</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-194"></span><span>    </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-195"></span><span>    </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-196"></span><span>      </span><span class="annot"><span class="annottext">Int -&gt; Dom s ()
forall s. Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#compress"><span class="hs-identifier hs-var">compress</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-197"></span><span>      </span><span id="local-6989586621680781337"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781337"><span class="hs-identifier hs-var">a</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-198"></span><span>      </span><span id="local-6989586621680781336"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781336"><span class="hs-identifier hs-var">l</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781344"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-199"></span><span>      </span><span id="local-6989586621680781335"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781335"><span class="hs-identifier hs-var">la</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781337"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-200"></span><span>      </span><span id="local-6989586621680781334"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781334"><span class="hs-identifier hs-var">sl</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781336"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-201"></span><span>      </span><span id="local-6989586621680781333"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781333"><span class="hs-identifier hs-var">sla</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781335"><span class="hs-identifier hs-var">la</span></a></span><span>
</span><span id="line-202"></span><span>      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781334"><span class="hs-identifier hs-var">sl</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781333"><span class="hs-identifier hs-var">sla</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-203"></span><span>        </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781336"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-204"></span><span>        </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781335"><span class="hs-identifier hs-var">la</span></a></span><span>
</span><span id="line-205"></span><span>
</span><span id="line-206"></span><span id="local-6989586621680781331"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#compress"><span class="hs-identifier hs-type">compress</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781331"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-207"></span><span id="compress"><span class="annot"><span class="annottext">compress :: forall s. Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#compress"><span class="hs-identifier hs-var hs-var">compress</span></a></span></span><span> </span><span id="local-6989586621680781313"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-208"></span><span>  </span><span id="local-6989586621680781312"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781312"><span class="hs-identifier hs-var">n0</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-var">zeroM</span></a></span><span>
</span><span id="line-209"></span><span>  </span><span id="local-6989586621680781311"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781311"><span class="hs-identifier hs-var">a</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-210"></span><span>  </span><span id="local-6989586621680781310"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781310"><span class="hs-identifier hs-var">aa</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781311"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-211"></span><span>  </span><span class="annot"><span class="annottext">Bool -&gt; Dom s () -&gt; Dom s ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781310"><span class="hs-identifier hs-var">aa</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781312"><span class="hs-identifier hs-var">n0</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-212"></span><span>    </span><span class="annot"><span class="annottext">Int -&gt; Dom s ()
forall s. Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#compress"><span class="hs-identifier hs-var">compress</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781311"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-213"></span><span>    </span><span id="local-6989586621680781309"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781309"><span class="hs-identifier hs-var">a</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-214"></span><span>    </span><span id="local-6989586621680781308"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781308"><span class="hs-identifier hs-var">aa</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var">ancestorM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781309"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-215"></span><span>    </span><span id="local-6989586621680781307"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781307"><span class="hs-identifier hs-var">l</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-216"></span><span>    </span><span id="local-6989586621680781306"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781306"><span class="hs-identifier hs-var">la</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781309"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-217"></span><span>    </span><span id="local-6989586621680781305"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781305"><span class="hs-identifier hs-var">sl</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781307"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-218"></span><span>    </span><span id="local-6989586621680781304"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781304"><span class="hs-identifier hs-var">sla</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781306"><span class="hs-identifier hs-var">la</span></a></span><span>
</span><span id="line-219"></span><span>    </span><span class="annot"><span class="annottext">Bool -&gt; Dom s () -&gt; Dom s ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781304"><span class="hs-identifier hs-var">sla</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781305"><span class="hs-identifier hs-var">sl</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-220"></span><span>      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781306"><span class="hs-identifier hs-var">la</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-221"></span><span>    </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781313"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781308"><span class="hs-identifier hs-var">aa</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-222"></span><span>
</span><span id="line-223"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-224"></span><span>
</span><span id="line-225"></span><span id="local-6989586621680781745"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#link"><span class="hs-identifier hs-type">link</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781745"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-226"></span><span id="link"><span class="annot"><span class="annottext">link :: forall s. Int -&gt; Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#link"><span class="hs-identifier hs-var hs-var">link</span></a></span></span><span> </span><span id="local-6989586621680781281"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span id="local-6989586621680781280"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781280"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-227"></span><span>  </span><span id="local-6989586621680781279"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781279"><span class="hs-identifier hs-var">n0</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-var">zeroM</span></a></span><span>
</span><span id="line-228"></span><span>  </span><span id="local-6989586621680781278"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781278"><span class="hs-identifier hs-var">lw</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781280"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-229"></span><span>  </span><span id="local-6989586621680781277"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781277"><span class="hs-identifier hs-var">slw</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781278"><span class="hs-identifier hs-var">lw</span></a></span><span>
</span><span id="line-230"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781255"><span class="annot"><span class="annottext">balance :: Int -&gt; S s (Env s) Int
</span><a href="#local-6989586621680781255"><span class="hs-identifier hs-var hs-var">balance</span></a></span></span><span> </span><span id="local-6989586621680781254"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-231"></span><span>        </span><span id="local-6989586621680781253"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-var">childM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-232"></span><span>        </span><span id="local-6989586621680781251"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781251"><span class="hs-identifier hs-var">lc</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-233"></span><span>        </span><span id="local-6989586621680781250"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781250"><span class="hs-identifier hs-var">slc</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781251"><span class="hs-identifier hs-var">lc</span></a></span><span>
</span><span id="line-234"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781277"><span class="hs-identifier hs-var">slw</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781250"><span class="hs-identifier hs-var">slc</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-235"></span><span>          </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-236"></span><span>          </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-237"></span><span>            </span><span id="local-6989586621680781249"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781249"><span class="hs-identifier hs-var">zs</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-238"></span><span>            </span><span id="local-6989586621680781247"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781247"><span class="hs-identifier hs-var">zc</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-239"></span><span>            </span><span id="local-6989586621680781246"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781246"><span class="hs-identifier hs-var">cc</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-var">childM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-240"></span><span>            </span><span id="local-6989586621680781245"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781245"><span class="hs-identifier hs-var">zcc</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781246"><span class="hs-identifier hs-var">cc</span></a></span><span>
</span><span id="line-241"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781247"><span class="hs-identifier hs-var">zc</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781249"><span class="hs-identifier hs-var">zs</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781245"><span class="hs-identifier hs-var">zcc</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-242"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-243"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-244"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childE"><span class="hs-identifier hs-var hs-var">childE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781246"><span class="hs-identifier hs-var">cc</span></a></span><span>
</span><span id="line-245"></span><span>                </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
</span><a href="#local-6989586621680781255"><span class="hs-identifier hs-var">balance</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-246"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-247"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeE"><span class="hs-identifier hs-var hs-var">sizeE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781249"><span class="hs-identifier hs-var">zs</span></a></span><span>
</span><span id="line-248"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781254"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-249"></span><span>                </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) Int
</span><a href="#local-6989586621680781255"><span class="hs-identifier hs-var">balance</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781253"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-250"></span><span>  </span><span id="local-6989586621680781242"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781242"><span class="hs-identifier hs-var">s</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="#local-6989586621680781255"><span class="hs-identifier hs-var">balance</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781280"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-251"></span><span>  </span><span id="local-6989586621680781241"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781241"><span class="hs-identifier hs-var">lw</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var">labelM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781280"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-252"></span><span>  </span><span id="local-6989586621680781240"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781240"><span class="hs-identifier hs-var">zw</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781280"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-253"></span><span>  </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781242"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781241"><span class="hs-identifier hs-var">lw</span></a></span><span>
</span><span id="line-254"></span><span>  </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeE"><span class="hs-identifier hs-var hs-var">sizeE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Dom s ()) -&gt; (Int -&gt; Int) -&gt; Int -&gt; Dom s ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781240"><span class="hs-identifier hs-var">zw</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Dom s ()) -&gt; Dom s Int -&gt; Dom s ()
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-255"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781234"><span class="annot"><span class="annottext">follow :: Int -&gt; S z (Env z) ()
</span><a href="#local-6989586621680781234"><span class="hs-identifier hs-var hs-var">follow</span></a></span></span><span> </span><span id="local-6989586621680781233"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781233"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-256"></span><span>        </span><span class="annot"><span class="annottext">Bool -&gt; S z (Env z) () -&gt; S z (Env z) ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781233"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781279"><span class="hs-identifier hs-var">n0</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span>
</span><span id="line-257"></span><span>          </span><span class="annot"><span class="annottext">(Env z -&gt; Arr z Int) -&gt; Int -&gt; Int -&gt; S z (Env z) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env z -&gt; Arr z Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781233"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-258"></span><span>          </span><span class="annot"><span class="annottext">Int -&gt; S z (Env z) ()
</span><a href="#local-6989586621680781234"><span class="hs-identifier hs-var">follow</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; S z (Env z) ()) -&gt; S z (Env z) Int -&gt; S z (Env z) ()
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; S z (Env z) Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-var">childM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781233"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-259"></span><span>  </span><span id="local-6989586621680781232"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781232"><span class="hs-identifier hs-var">zv</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var">sizeM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-260"></span><span>  </span><span class="annot"><span class="annottext">Int -&gt; Dom s ()
forall s. Int -&gt; Dom s ()
</span><a href="#local-6989586621680781234"><span class="hs-identifier hs-var">follow</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Dom s ()) -&gt; Dom s Int -&gt; Dom s ()
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; m b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3D%3C%3C"><span class="hs-operator hs-var">=&lt;&lt;</span></a></span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781232"><span class="hs-identifier hs-var">zv</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781240"><span class="hs-identifier hs-var">zw</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-261"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781242"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-262"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-263"></span><span>                </span><span id="local-6989586621680781231"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781231"><span class="hs-identifier hs-var">cv</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-var">childM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-264"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childE"><span class="hs-identifier hs-var hs-var">childE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781281"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781242"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-265"></span><span>                </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781231"><span class="hs-identifier hs-var">cv</span></a></span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-268"></span><span>
</span><span id="line-269"></span><span id="local-6989586621680781765"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsDom"><span class="hs-identifier hs-type">dfsDom</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781765"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-270"></span><span id="dfsDom"><span class="annot"><span class="annottext">dfsDom :: forall s. Int -&gt; Dom s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsDom"><span class="hs-identifier hs-var hs-var">dfsDom</span></a></span></span><span> </span><span id="local-6989586621680781226"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781226"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-271"></span><span>  </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s ()
forall s. Int -&gt; Dom s ()
</span><a href="#local-6989586621680781225"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781226"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-272"></span><span>  </span><span id="local-6989586621680781224"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781224"><span class="hs-identifier hs-var">n0</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-var">zeroM</span></a></span><span>
</span><span id="line-273"></span><span>  </span><span id="local-6989586621680781223"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781223"><span class="hs-identifier hs-var">r</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootM"><span class="hs-identifier hs-var">rootM</span></a></span><span>
</span><span id="line-274"></span><span>  </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; Dom s ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentE"><span class="hs-identifier hs-var hs-var">parentE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781223"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781224"><span class="hs-identifier hs-var">n0</span></a></span><span>
</span><span id="line-275"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680781225"><span class="annot"><span class="annottext">go :: Int -&gt; S s (Env s) ()
</span><a href="#local-6989586621680781225"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680781204"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-276"></span><span>          </span><span id="local-6989586621680781203"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781203"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Dom s Int
forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#nextM"><span class="hs-identifier hs-var">nextM</span></a></span><span>
</span><span id="line-277"></span><span>          </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfnE"><span class="hs-identifier hs-var hs-var">dfnE</span></a></span><span>   </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781203"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-278"></span><span>          </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoE"><span class="hs-identifier hs-var hs-var">sdnoE</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781203"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-279"></span><span>          </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsE"><span class="hs-identifier hs-var hs-var">ndfsE</span></a></span><span>  </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781203"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-280"></span><span>          </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-281"></span><span>          </span><span id="local-6989586621680781201"><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781201"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Path
forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#succsM"><span class="hs-identifier hs-var">succsM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-282"></span><span>          </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; S s (Env s) ()) -&gt; S s (Env s) ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781201"><span class="hs-identifier hs-var">ss</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781199"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781199"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-283"></span><span>            </span><span id="local-6989586621680781198"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781198"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var">sdnoM</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781199"><span class="hs-identifier hs-var">j</span></a></span><span>
</span><span id="line-284"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781198"><span class="hs-identifier hs-var">s</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-285"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">() -&gt; S s (Env s) ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-286"></span><span>              </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-287"></span><span>                </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; Int -&gt; S s (Env s) ()
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var">store</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentE"><span class="hs-identifier hs-var hs-var">parentE</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781199"><span class="hs-identifier hs-var">j</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781204"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-288"></span><span>                </span><span class="annot"><span class="annottext">Int -&gt; S s (Env s) ()
</span><a href="#local-6989586621680781225"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781199"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-289"></span><span>
</span><span id="line-290"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-291"></span><span>
</span><span id="line-292"></span><span id="local-6989586621680781802"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#initEnv"><span class="hs-identifier hs-type">initEnv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781802"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Env"><span class="hs-identifier hs-type">Env</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781802"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-293"></span><span id="initEnv"><span class="annot"><span class="annottext">initEnv :: forall s. Rooted -&gt; ST s (Env s)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#initEnv"><span class="hs-identifier hs-var hs-var">initEnv</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680781140"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781140"><span class="hs-identifier hs-var">r0</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680781139"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781139"><span class="hs-identifier hs-var">g0</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-294"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680781138"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781138"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680781137"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680781137"><span class="hs-identifier hs-var">rnmap</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IntMap IntSet -&gt; (IntMap IntSet, NodeMap Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#renum"><span class="hs-identifier hs-var">renum</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781139"><span class="hs-identifier hs-var">g0</span></a></span><span>
</span><span id="line-295"></span><span>      </span><span id="local-6989586621680781135"><span class="annot"><span class="annottext">pred :: IntMap IntSet
</span><a href="#local-6989586621680781135"><span class="hs-identifier hs-var hs-var">pred</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predG"><span class="hs-identifier hs-var">predG</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781138"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-296"></span><span>      </span><span id="local-6989586621680781134"><span class="annot"><span class="annottext">r :: Int
</span><a href="#local-6989586621680781134"><span class="hs-identifier hs-var hs-var">r</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680781137"><span class="hs-identifier hs-var">rnmap</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int -&gt; Int -&gt; Int
forall a. IntMap a -&gt; Int -&gt; a
</span><a href="../../containers/src/Data.IntMap.Internal.html#%21"><span class="hs-operator hs-var">IM.!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781140"><span class="hs-identifier hs-var">r0</span></a></span><span>
</span><span id="line-297"></span><span>      </span><span id="local-6989586621680781132"><span class="annot"><span class="annottext">n :: Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int
forall a. IntMap a -&gt; Int
</span><a href="../../containers/src/Data.IntMap.Internal.html#size"><span class="hs-identifier hs-var">IM.size</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781138"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-298"></span><span>      </span><span id="local-6989586621680781128"><span class="annot"><span class="annottext">ns :: Path
</span><a href="#local-6989586621680781128"><span class="hs-identifier hs-var hs-var">ns</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-299"></span><span>      </span><span id="local-6989586621680781125"><span class="annot"><span class="annottext">m :: Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var hs-var">m</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-300"></span><span>
</span><span id="line-301"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781123"><span class="annot"><span class="annottext">bucket :: IntMap IntSet
</span><a href="#local-6989586621680781123"><span class="hs-identifier hs-var hs-var">bucket</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, IntSet)] -&gt; IntMap IntSet
forall a. [(Int, a)] -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#fromList"><span class="hs-identifier hs-var">IM.fromList</span></a></span><span>
</span><span id="line-302"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Path -&gt; [IntSet] -&gt; [(Int, IntSet)]
forall a b. [a] -&gt; [b] -&gt; [(a, b)]
</span><a href="../../base/src/GHC.List.html#zip"><span class="hs-identifier hs-var">zip</span></a></span><span> </span><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680781128"><span class="hs-identifier hs-var">ns</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; [IntSet]
forall a. a -&gt; [a]
</span><a href="../../base/src/GHC.List.html#repeat"><span class="hs-identifier hs-var">repeat</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-303"></span><span>
</span><span id="line-304"></span><span>  </span><span id="local-6989586621680781120"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781120"><span class="hs-identifier hs-var">rna</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-305"></span><span>  </span><span class="annot"><span class="annottext">Arr s Int -&gt; [(Int, Int)] -&gt; ST s ()
forall s a.
MArray (A s) a (ST s) =&gt;
Arr s a -&gt; [(Int, a)] -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#writes"><span class="hs-identifier hs-var">writes</span></a></span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781120"><span class="hs-identifier hs-var">rna</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">((Int, Int) -&gt; (Int, Int)) -&gt; [(Int, Int)] -&gt; [(Int, Int)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; (Int, Int)
forall a b. (a, b) -&gt; (b, a)
</span><a href="../../base/src/Data.Tuple.html#swap"><span class="hs-identifier hs-var">swap</span></a></span><span>
</span><span id="line-306"></span><span>        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">NodeMap Int -&gt; [(Int, Int)]
forall a. IntMap a -&gt; [(Int, a)]
</span><a href="../../containers/src/Data.IntMap.Internal.html#toList"><span class="hs-identifier hs-var">IM.toList</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680781137"><span class="hs-identifier hs-var">rnmap</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-307"></span><span>
</span><span id="line-308"></span><span>  </span><span id="local-6989586621680781116"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781116"><span class="hs-identifier hs-var">doms</span></a></span></span><span>      </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-309"></span><span>  </span><span id="local-6989586621680781115"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781115"><span class="hs-identifier hs-var">sdno</span></a></span></span><span>      </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-310"></span><span>  </span><span id="local-6989586621680781114"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781114"><span class="hs-identifier hs-var">size</span></a></span></span><span>      </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-311"></span><span>  </span><span id="local-6989586621680781113"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781113"><span class="hs-identifier hs-var">parent</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-312"></span><span>  </span><span id="local-6989586621680781112"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781112"><span class="hs-identifier hs-var">ancestor</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-313"></span><span>  </span><span id="local-6989586621680781111"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781111"><span class="hs-identifier hs-var">child</span></a></span></span><span>     </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-314"></span><span>  </span><span id="local-6989586621680781110"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781110"><span class="hs-keyword hs-var">label</span></a></span></span><span>     </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-315"></span><span>  </span><span id="local-6989586621680781109"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781109"><span class="hs-identifier hs-var">ndfs</span></a></span></span><span>      </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-316"></span><span>  </span><span id="local-6989586621680781108"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781108"><span class="hs-identifier hs-var">dfn</span></a></span></span><span>       </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var">newI</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781125"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-317"></span><span>
</span><span id="line-318"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781116"><span class="hs-identifier hs-var">doms</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-319"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781115"><span class="hs-identifier hs-var">sdno</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-320"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781114"><span class="hs-identifier hs-var">size</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-321"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781112"><span class="hs-identifier hs-var">ancestor</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-322"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781132"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781111"><span class="hs-identifier hs-var">child</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-323"></span><span>
</span><span id="line-324"></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781116"><span class="hs-identifier hs-var">doms</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781134"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781134"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-325"></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781114"><span class="hs-identifier hs-var">size</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-326"></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781110"><span class="hs-keyword hs-var">label</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-327"></span><span>
</span><span id="line-328"></span><span>  </span><span class="annot"><span class="annottext">Env s -&gt; ST s (Env s)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Env :: forall s.
IntMap IntSet
-&gt; IntMap IntSet
-&gt; IntMap IntSet
-&gt; Int
-&gt; Int
-&gt; Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Arr s Int
-&gt; Env s
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#Env"><span class="hs-identifier hs-type">Env</span></a></span><span>
</span><span id="line-329"></span><span>    </span><span class="hs-special">{</span><span class="annot"><span class="annottext">rnE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rnE"><span class="hs-identifier hs-var">rnE</span></a></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781120"><span class="hs-identifier hs-var">rna</span></a></span><span>
</span><span id="line-330"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">dfsE :: Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsE"><span class="hs-identifier hs-var">dfsE</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-331"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">zeroE :: Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroE"><span class="hs-identifier hs-var">zeroE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-332"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">rootE :: Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootE"><span class="hs-identifier hs-var">rootE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781134"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-333"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">labelE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var">labelE</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781110"><span class="hs-keyword hs-var">label</span></a></span><span>
</span><span id="line-334"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">parentE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentE"><span class="hs-identifier hs-var">parentE</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781113"><span class="hs-identifier hs-var">parent</span></a></span><span>
</span><span id="line-335"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">ancestorE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var">ancestorE</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781112"><span class="hs-identifier hs-var">ancestor</span></a></span><span>
</span><span id="line-336"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">childE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childE"><span class="hs-identifier hs-var">childE</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781111"><span class="hs-identifier hs-var">child</span></a></span><span>
</span><span id="line-337"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">ndfsE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsE"><span class="hs-identifier hs-var">ndfsE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781109"><span class="hs-identifier hs-var">ndfs</span></a></span><span>
</span><span id="line-338"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">dfnE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfnE"><span class="hs-identifier hs-var">dfnE</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781108"><span class="hs-identifier hs-var">dfn</span></a></span><span>
</span><span id="line-339"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">sdnoE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoE"><span class="hs-identifier hs-var">sdnoE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781115"><span class="hs-identifier hs-var">sdno</span></a></span><span>
</span><span id="line-340"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">sizeE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeE"><span class="hs-identifier hs-var">sizeE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781114"><span class="hs-identifier hs-var">size</span></a></span><span>
</span><span id="line-341"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">succE :: IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#succE"><span class="hs-identifier hs-var">succE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781138"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-342"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">predE :: IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predE"><span class="hs-identifier hs-var">predE</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781135"><span class="hs-identifier hs-var">pred</span></a></span><span>
</span><span id="line-343"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">bucketE :: IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketE"><span class="hs-identifier hs-var">bucketE</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680781123"><span class="hs-identifier hs-var">bucket</span></a></span><span>
</span><span id="line-344"></span><span>    </span><span class="hs-special">,</span><span class="annot"><span class="annottext">domE :: Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var">domE</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781116"><span class="hs-identifier hs-var">doms</span></a></span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-345"></span><span>
</span><span id="line-346"></span><span id="local-6989586621680781106"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEnv"><span class="hs-identifier hs-type">fromEnv</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781106"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span></span><span>
</span><span id="line-347"></span><span id="fromEnv"><span class="annot"><span class="annottext">fromEnv :: forall s. Dom s [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEnv"><span class="hs-identifier hs-var hs-var">fromEnv</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-348"></span><span>  </span><span id="local-6989586621680781087"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781087"><span class="hs-identifier hs-var">dom</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; S s (Env s) (Arr s Int)
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var hs-var">domE</span></a></span><span>
</span><span id="line-349"></span><span>  </span><span id="local-6989586621680781086"><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781086"><span class="hs-identifier hs-var">rn</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; S s (Env s) (Arr s Int)
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rnE"><span class="hs-identifier hs-var hs-var">rnE</span></a></span><span>
</span><span id="line-350"></span><span>  </span><span class="hs-comment">-- r     &lt;- gets rootE</span><span>
</span><span id="line-351"></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span class="hs-special">,</span><span id="local-6989586621680781085"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781085"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ST s (Int, Int) -&gt; S s (Env s) (Int, Int)
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int -&gt; ST s (Int, Int)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="../../array/src/Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781087"><span class="hs-identifier hs-var">dom</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-352"></span><span>  </span><span class="annot"><span class="annottext">Path -&gt; (Int -&gt; S s (Env s) (Int, Int)) -&gt; Dom s [(Int, Int)]
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Traversable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m (t b)
</span><a href="../../base/src/Data.Traversable.html#forM"><span class="hs-identifier hs-var">forM</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781085"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781081"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781081"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-353"></span><span>    </span><span id="local-6989586621680781080"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781080"><span class="hs-identifier hs-var">j</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ST s Int -&gt; S s (Env s) Int
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781086"><span class="hs-identifier hs-var">rn</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; ST s Int
forall s a. MArray (A s) a (ST s) =&gt; A s Int a -&gt; Int -&gt; ST s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-var">!:</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781081"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-354"></span><span>    </span><span id="local-6989586621680781078"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781078"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ST s Int -&gt; S s (Env s) Int
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781087"><span class="hs-identifier hs-var">dom</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; ST s Int
forall s a. MArray (A s) a (ST s) =&gt; A s Int a -&gt; Int -&gt; ST s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-var">!:</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781081"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-355"></span><span>    </span><span id="local-6989586621680781077"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781077"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ST s Int -&gt; S s (Env s) Int
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s Int
</span><a href="#local-6989586621680781086"><span class="hs-identifier hs-var">rn</span></a></span><span class="annot"><span class="annottext">Arr s Int -&gt; Int -&gt; ST s Int
forall s a. MArray (A s) a (ST s) =&gt; A s Int a -&gt; Int -&gt; ST s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-var">!:</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781078"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-356"></span><span>    </span><span class="annot"><span class="annottext">(Int, Int) -&gt; S s (Env s) (Int, Int)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781080"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781077"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-357"></span><span>
</span><span id="line-358"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-359"></span><span>
</span><span id="line-360"></span><span id="local-6989586621680781076"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-type">zeroM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781076"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-361"></span><span id="zeroM"><span class="annot"><span class="annottext">zeroM :: forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroM"><span class="hs-identifier hs-var hs-var">zeroM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Int) -&gt; S s (Env s) Int
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Int
forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#zeroE"><span class="hs-identifier hs-var hs-var">zeroE</span></a></span><span>
</span><span id="line-362"></span><span id="local-6989586621680781075"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#domM"><span class="hs-identifier hs-type">domM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781075"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-363"></span><span id="domM"><span class="annot"><span class="annottext">domM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domM"><span class="hs-identifier hs-var hs-var">domM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#domE"><span class="hs-identifier hs-var hs-var">domE</span></a></span><span>
</span><span id="line-364"></span><span id="local-6989586621680781764"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#rootM"><span class="hs-identifier hs-type">rootM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781764"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-365"></span><span id="rootM"><span class="annot"><span class="annottext">rootM :: forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootM"><span class="hs-identifier hs-var hs-var">rootM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Int) -&gt; S s (Env s) Int
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Int
forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#rootE"><span class="hs-identifier hs-var hs-var">rootE</span></a></span><span>
</span><span id="line-366"></span><span id="local-6989586621680781072"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#succsM"><span class="hs-identifier hs-type">succsM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781072"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-367"></span><span id="succsM"><span class="annot"><span class="annottext">succsM :: forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#succsM"><span class="hs-identifier hs-var hs-var">succsM</span></a></span></span><span> </span><span id="local-6989586621680781070"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781070"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Path) -&gt; S s (Env s) Path
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; Path) -&gt; (Env s -&gt; IntSet) -&gt; Env s -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int -&gt; IntSet
forall a. Monoid a =&gt; IntMap a -&gt; Int -&gt; a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-var">!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781070"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; IntSet)
-&gt; (Env s -&gt; IntMap IntSet) -&gt; Env s -&gt; IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; IntMap IntSet
forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#succE"><span class="hs-identifier hs-var hs-var">succE</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-368"></span><span id="local-6989586621680781754"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#predsM"><span class="hs-identifier hs-type">predsM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781754"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-369"></span><span id="predsM"><span class="annot"><span class="annottext">predsM :: forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predsM"><span class="hs-identifier hs-var hs-var">predsM</span></a></span></span><span> </span><span id="local-6989586621680781066"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781066"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Path) -&gt; S s (Env s) Path
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; Path) -&gt; (Env s -&gt; IntSet) -&gt; Env s -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int -&gt; IntSet
forall a. Monoid a =&gt; IntMap a -&gt; Int -&gt; a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-var">!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781066"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; IntSet)
-&gt; (Env s -&gt; IntMap IntSet) -&gt; Env s -&gt; IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; IntMap IntSet
forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predE"><span class="hs-identifier hs-var hs-var">predE</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-370"></span><span id="local-6989586621680781065"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketM"><span class="hs-identifier hs-type">bucketM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781065"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-371"></span><span id="bucketM"><span class="annot"><span class="annottext">bucketM :: forall s. Int -&gt; Dom s Path
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketM"><span class="hs-identifier hs-var hs-var">bucketM</span></a></span></span><span> </span><span id="local-6989586621680781063"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781063"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Path) -&gt; S s (Env s) Path
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; Path) -&gt; (Env s -&gt; IntSet) -&gt; Env s -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int -&gt; IntSet
forall a. Monoid a =&gt; IntMap a -&gt; Int -&gt; a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-var">!</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781063"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; IntSet)
-&gt; (Env s -&gt; IntMap IntSet) -&gt; Env s -&gt; IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; IntMap IntSet
forall s. Env s -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#bucketE"><span class="hs-identifier hs-var hs-var">bucketE</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-372"></span><span id="local-6989586621680781062"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-type">sizeM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781062"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span></span><span>
</span><span id="line-373"></span><span id="sizeM"><span class="annot"><span class="annottext">sizeM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeM"><span class="hs-identifier hs-var hs-var">sizeM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sizeE"><span class="hs-identifier hs-var hs-var">sizeE</span></a></span><span>
</span><span id="line-374"></span><span id="local-6989586621680781060"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-type">sdnoM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781060"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span></span><span>
</span><span id="line-375"></span><span id="sdnoM"><span class="annot"><span class="annottext">sdnoM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoM"><span class="hs-identifier hs-var hs-var">sdnoM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#sdnoE"><span class="hs-identifier hs-var hs-var">sdnoE</span></a></span><span>
</span><span id="line-376"></span><span class="hs-comment">-- dfnM :: Node -&gt; Dom s Int</span><span>
</span><span id="line-377"></span><span class="hs-comment">-- dfnM = fetch dfnE</span><span>
</span><span id="line-378"></span><span id="local-6989586621680781755"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-type">ndfsM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781755"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-379"></span><span id="ndfsM"><span class="annot"><span class="annottext">ndfsM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsM"><span class="hs-identifier hs-var hs-var">ndfsM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ndfsE"><span class="hs-identifier hs-var hs-var">ndfsE</span></a></span><span>
</span><span id="line-380"></span><span id="local-6989586621680781057"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-type">childM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781057"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-381"></span><span id="childM"><span class="annot"><span class="annottext">childM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childM"><span class="hs-identifier hs-var hs-var">childM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#childE"><span class="hs-identifier hs-var hs-var">childE</span></a></span><span>
</span><span id="line-382"></span><span id="local-6989586621680781055"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-type">ancestorM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781055"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-383"></span><span id="ancestorM"><span class="annot"><span class="annottext">ancestorM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorM"><span class="hs-identifier hs-var hs-var">ancestorM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestorE"><span class="hs-identifier hs-var hs-var">ancestorE</span></a></span><span>
</span><span id="line-384"></span><span id="local-6989586621680781053"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#parentM"><span class="hs-identifier hs-type">parentM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781053"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-385"></span><span id="parentM"><span class="annot"><span class="annottext">parentM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentM"><span class="hs-identifier hs-var hs-var">parentM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parentE"><span class="hs-identifier hs-var hs-var">parentE</span></a></span><span>
</span><span id="line-386"></span><span id="local-6989586621680781051"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-type">labelM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781051"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span></span><span>
</span><span id="line-387"></span><span id="labelM"><span class="annot"><span class="annottext">labelM :: forall s. Int -&gt; Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelM"><span class="hs-identifier hs-var hs-var">labelM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Arr s Int) -&gt; Int -&gt; S s (Env s) Int
forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var">fetch</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Arr s Int
forall s. Env s -&gt; Arr s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span><span>
</span><span id="line-388"></span><span id="local-6989586621680781049"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#nextM"><span class="hs-identifier hs-type">nextM</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Dom"><span class="hs-identifier hs-type">Dom</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781049"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span></span><span>
</span><span id="line-389"></span><span id="nextM"><span class="annot"><span class="annottext">nextM :: forall s. Dom s Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#nextM"><span class="hs-identifier hs-var hs-var">nextM</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-390"></span><span>  </span><span id="local-6989586621680781045"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781045"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Env s -&gt; Int) -&gt; Dom s Int
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">Env s -&gt; Int
forall s. Env s -&gt; Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsE"><span class="hs-identifier hs-var hs-var">dfsE</span></a></span><span>
</span><span id="line-391"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680781042"><span class="annot"><span class="annottext">n' :: Int
</span><a href="#local-6989586621680781042"><span class="hs-identifier hs-var hs-var">n'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781045"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-392"></span><span>  </span><span class="annot"><span class="annottext">(Env s -&gt; Env s) -&gt; S s (Env s) ()
forall s z. (s -&gt; s) -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#modify"><span class="hs-identifier hs-var">modify</span></a></span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680781041"><span class="annot"><span class="annottext">Env s
</span><a href="#local-6989586621680781041"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-glyph">-&gt;</span><span class="annot"><span class="annottext">Env s
</span><a href="#local-6989586621680781041"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">{</span><span class="annot"><span class="annottext">dfsE :: Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#dfsE"><span class="hs-identifier hs-var">dfsE</span></a></span><span class="hs-glyph">=</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781042"><span class="hs-identifier hs-var">n'</span></a></span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-393"></span><span>  </span><span class="annot"><span class="annottext">Int -&gt; Dom s Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781042"><span class="hs-identifier hs-var">n'</span></a></span><span>
</span><span id="line-394"></span><span>
</span><span id="line-395"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-396"></span><span>
</span><span id="line-397"></span><span class="hs-keyword">type</span><span> </span><span id="A"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-var">A</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.Base.html#STUArray"><span class="hs-identifier hs-type">STUArray</span></a></span><span>
</span><span id="line-398"></span><span class="hs-keyword">type</span><span> </span><span id="Arr"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-var">Arr</span></a></span></span><span> </span><span id="local-6989586621680781040"><span class="annot"><a href="#local-6989586621680781040"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span id="local-6989586621680781039"><span class="annot"><a href="#local-6989586621680781039"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781040"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="#local-6989586621680781039"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-399"></span><span>
</span><span id="line-400"></span><span class="hs-keyword">infixl</span><span> </span><span class="hs-number">9</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-type">!:</span></a></span><span>
</span><span id="line-401"></span><span class="hs-keyword">infixr</span><span> </span><span class="hs-number">2</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-type">.=</span></a></span><span>
</span><span id="line-402"></span><span>
</span><span id="line-403"></span><span id="local-6989586621680781722"><span id="local-6989586621680781723"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-type">(.=)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781723"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781722"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781723"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-404"></span><span>     </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781723"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781722"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781722"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781723"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-405"></span><span class="hs-special">(</span><span id="local-6989586621680781033"><span class="annot"><span class="annottext">Arr s a
</span><a href="#local-6989586621680781033"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span id=".%3D"><span class="annot"><span class="annottext">.= :: forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var hs-var">.=</span></a></span></span><span> </span><span id="local-6989586621680781032"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781032"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680781031"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781031"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-406"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="GHC.Utils.Misc.html#debugIsOn"><span class="hs-identifier hs-var">debugIsOn</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s a -&gt; Int -&gt; a -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#writeArray"><span class="hs-identifier hs-var">writeArray</span></a></span><span> </span><span class="annot"><span class="annottext">Arr s a
</span><a href="#local-6989586621680781033"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781031"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781032"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-407"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Arr s a -&gt; Int -&gt; a -&gt; ST s ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="../../array/src/Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">Arr s a
</span><a href="#local-6989586621680781033"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781031"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781032"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-408"></span><span>
</span><span id="line-409"></span><span id="local-6989586621680781708"><span id="local-6989586621680781709"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-type">(!:)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781709"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781708"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781709"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-410"></span><span>     </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781709"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="#local-6989586621680781708"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781709"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781708"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-411"></span><span id="local-6989586621680781017"><span class="annot"><span class="annottext">A s Int a
</span><a href="#local-6989586621680781017"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="%21%3A"><span class="annot"><span class="annottext">!: :: forall s a. MArray (A s) a (ST s) =&gt; A s Int a -&gt; Int -&gt; ST s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-var hs-var">!:</span></a></span></span><span> </span><span id="local-6989586621680781016"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781016"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-412"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="GHC.Utils.Misc.html#debugIsOn"><span class="hs-identifier hs-var">debugIsOn</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-413"></span><span>      </span><span id="local-6989586621680781015"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781015"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">A s Int a -&gt; Int -&gt; ST s a
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; i -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#readArray"><span class="hs-identifier hs-var">readArray</span></a></span><span> </span><span class="annot"><span class="annottext">A s Int a
</span><a href="#local-6989586621680781017"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781016"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-414"></span><span>      </span><span class="annot"><span class="annottext">a -&gt; ST s a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; ST s a) -&gt; a -&gt; ST s a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781015"><span class="hs-identifier hs-var">o</span></a></span><span>
</span><span id="line-415"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-416"></span><span>      </span><span id="local-6989586621680781012"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781012"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">A s Int a -&gt; Int -&gt; ST s a
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="../../array/src/Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">A s Int a
</span><a href="#local-6989586621680781017"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781016"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-417"></span><span>      </span><span class="annot"><span class="annottext">a -&gt; ST s a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; ST s a) -&gt; a -&gt; ST s a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680781012"><span class="hs-identifier hs-var">o</span></a></span><span>
</span><span id="line-418"></span><span>
</span><span id="line-419"></span><span id="local-6989586621680781671"><span id="local-6989586621680781672"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#new"><span class="hs-identifier hs-type">new</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781672"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781671"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781672"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-420"></span><span>    </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781672"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781672"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781671"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-421"></span><span id="new"><span class="annot"><span class="annottext">new :: forall s a. MArray (A s) a (ST s) =&gt; Int -&gt; ST s (Arr s a)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#new"><span class="hs-identifier hs-var hs-var">new</span></a></span></span><span> </span><span id="local-6989586621680781003"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781003"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; ST s (STUArray s Int a)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="../../array/src/Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680781003"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span>
</span><span id="line-422"></span><span>
</span><span id="line-423"></span><span id="local-6989586621680781727"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-type">newI</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781727"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781727"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span></span><span>
</span><span id="line-424"></span><span id="newI"><span class="annot"><span class="annottext">newI :: forall s. Int -&gt; ST s (Arr s Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#newI"><span class="hs-identifier hs-var hs-var">newI</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ST s (Arr s Int)
forall s a. MArray (A s) a (ST s) =&gt; Int -&gt; ST s (Arr s a)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#new"><span class="hs-identifier hs-var">new</span></a></span><span>
</span><span id="line-425"></span><span>
</span><span id="line-426"></span><span class="hs-comment">-- newD :: Int -&gt; ST s (Arr s Double)</span><span>
</span><span id="line-427"></span><span class="hs-comment">-- newD = new</span><span>
</span><span id="line-428"></span><span>
</span><span id="line-429"></span><span class="hs-comment">-- dump :: (MArray (A s) a (ST s)) =&gt; Arr s a -&gt; ST s [a]</span><span>
</span><span id="line-430"></span><span class="hs-comment">-- dump a = do</span><span>
</span><span id="line-431"></span><span class="hs-comment">--   (m,n) &lt;- getBounds a</span><span>
</span><span id="line-432"></span><span class="hs-comment">--   forM [m..n] (\i -&gt; a!:i)</span><span>
</span><span id="line-433"></span><span>
</span><span id="line-434"></span><span id="local-6989586621680781725"><span id="local-6989586621680781726"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#writes"><span class="hs-identifier hs-type">writes</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781726"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781725"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781726"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-435"></span><span>     </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781726"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781725"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680781725"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781726"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-436"></span><span id="writes"><span class="annot"><span class="annottext">writes :: forall s a.
MArray (A s) a (ST s) =&gt;
Arr s a -&gt; [(Int, a)] -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#writes"><span class="hs-identifier hs-var hs-var">writes</span></a></span></span><span> </span><span id="local-6989586621680780995"><span class="annot"><span class="annottext">Arr s a
</span><a href="#local-6989586621680780995"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680780994"><span class="annot"><span class="annottext">[(Int, a)]
</span><a href="#local-6989586621680780994"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, a)] -&gt; ((Int, a) -&gt; ST s ()) -&gt; ST s ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
t a -&gt; (a -&gt; m b) -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#forM_"><span class="hs-identifier hs-var">forM_</span></a></span><span> </span><span class="annot"><span class="annottext">[(Int, a)]
</span><a href="#local-6989586621680780994"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621680780993"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780993"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780992"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780992"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr s a
</span><a href="#local-6989586621680780995"><span class="hs-identifier hs-var">a</span></a></span><span class="annot"><span class="annottext">Arr s a -&gt; a -&gt; Int -&gt; ST s ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780992"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780993"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-437"></span><span>
</span><span id="line-438"></span><span class="hs-comment">-- arr :: (MArray (A s) a (ST s)) =&gt; [a] -&gt; ST s (Arr s a)</span><span>
</span><span id="line-439"></span><span class="hs-comment">-- arr xs = do</span><span>
</span><span id="line-440"></span><span class="hs-comment">--   let n = length xs</span><span>
</span><span id="line-441"></span><span class="hs-comment">--   a &lt;- new n</span><span>
</span><span id="line-442"></span><span class="hs-comment">--   go a n 0 xs</span><span>
</span><span id="line-443"></span><span class="hs-comment">--   return a</span><span>
</span><span id="line-444"></span><span class="hs-comment">--   where go _ _ _    [] = return ()</span><span>
</span><span id="line-445"></span><span class="hs-comment">--         go a n i (x:xs)</span><span>
</span><span id="line-446"></span><span class="hs-comment">--           | i &lt;= n = (a.=x) i &gt;&gt; go a n (i+1) xs</span><span>
</span><span id="line-447"></span><span class="hs-comment">--           | otherwise = return ()</span><span>
</span><span id="line-448"></span><span>
</span><span id="line-449"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-450"></span><span>
</span><span id="line-451"></span><span id="local-6989586621680781700"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-type">(!)</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781700"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781700"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781700"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-452"></span><span id="%21"><span class="annot"><span class="annottext">! :: forall a. Monoid a =&gt; IntMap a -&gt; Int -&gt; a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-var hs-var">(!)</span></a></span></span><span> </span><span id="local-6989586621680780989"><span class="annot"><span class="annottext">IntMap a
</span><a href="#local-6989586621680780989"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621680780988"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780988"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; (a -&gt; a) -&gt; Maybe a -&gt; a
forall b a. b -&gt; (a -&gt; b) -&gt; Maybe a -&gt; b
</span><a href="../../base/src/Data.Maybe.html#maybe"><span class="hs-identifier hs-var">maybe</span></a></span><span> </span><span class="annot"><span class="annottext">a
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntMap a -&gt; Maybe a
forall a. Int -&gt; IntMap a -&gt; Maybe a
</span><a href="../../containers/src/Data.IntMap.Internal.html#lookup"><span class="hs-identifier hs-var">IM.lookup</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780988"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap a
</span><a href="#local-6989586621680780989"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-453"></span><span>
</span><span id="line-454"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fromAdj"><span class="hs-identifier hs-type">fromAdj</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-455"></span><span id="fromAdj"><span class="annot"><span class="annottext">fromAdj :: [(Int, Path)] -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromAdj"><span class="hs-identifier hs-var hs-var">fromAdj</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, IntSet)] -&gt; IntMap IntSet
forall a. [(Int, a)] -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#fromList"><span class="hs-identifier hs-var">IM.fromList</span></a></span><span> </span><span class="annot"><span class="annottext">([(Int, IntSet)] -&gt; IntMap IntSet)
-&gt; ([(Int, Path)] -&gt; [(Int, IntSet)])
-&gt; [(Int, Path)]
-&gt; IntMap IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">((Int, Path) -&gt; (Int, IntSet)) -&gt; [(Int, Path)] -&gt; [(Int, IntSet)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Path -&gt; IntSet) -&gt; (Int, Path) -&gt; (Int, IntSet)
forall (p :: * -&gt; * -&gt; *) b c a.
Bifunctor p =&gt;
(b -&gt; c) -&gt; p a b -&gt; p a c
</span><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-identifier hs-var">second</span></a></span><span> </span><span class="annot"><span class="annottext">Path -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#fromList"><span class="hs-identifier hs-var">IS.fromList</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-456"></span><span>
</span><span id="line-457"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEdges"><span class="hs-identifier hs-type">fromEdges</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Edge"><span class="hs-identifier hs-type">Edge</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-458"></span><span id="fromEdges"><span class="annot"><span class="annottext">fromEdges :: [(Int, Int)] -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromEdges"><span class="hs-identifier hs-var hs-var">fromEdges</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet -&gt; IntSet)
-&gt; ((Int, Int) -&gt; Int)
-&gt; ((Int, Int) -&gt; IntSet)
-&gt; [(Int, Int)]
-&gt; IntMap IntSet
forall c a.
(c -&gt; c -&gt; c) -&gt; (a -&gt; Int) -&gt; (a -&gt; c) -&gt; [a] -&gt; IntMap c
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#collectI"><span class="hs-identifier hs-var">collectI</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#union"><span class="hs-identifier hs-var">IS.union</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; Int
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#singleton"><span class="hs-identifier hs-var">IS.singleton</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; IntSet) -&gt; ((Int, Int) -&gt; Int) -&gt; (Int, Int) -&gt; IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; Int
forall a b. (a, b) -&gt; b
</span><a href="../../base/src/Data.Tuple.html#snd"><span class="hs-identifier hs-var">snd</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#toAdj"><span class="hs-identifier hs-type">toAdj</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span><span class="hs-special">]</span><span>
</span><span id="line-461"></span><span id="toAdj"><span class="annot"><span class="annottext">toAdj :: IntMap IntSet -&gt; [(Int, Path)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#toAdj"><span class="hs-identifier hs-var hs-var">toAdj</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((Int, IntSet) -&gt; (Int, Path)) -&gt; [(Int, IntSet)] -&gt; [(Int, Path)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(IntSet -&gt; Path) -&gt; (Int, IntSet) -&gt; (Int, Path)
forall (p :: * -&gt; * -&gt; *) b c a.
Bifunctor p =&gt;
(b -&gt; c) -&gt; p a b -&gt; p a c
</span><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-identifier hs-var">second</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([(Int, IntSet)] -&gt; [(Int, Path)])
-&gt; (IntMap IntSet -&gt; [(Int, IntSet)])
-&gt; IntMap IntSet
-&gt; [(Int, Path)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; [(Int, IntSet)]
forall a. IntMap a -&gt; [(Int, a)]
</span><a href="../../containers/src/Data.IntMap.Internal.html#toList"><span class="hs-identifier hs-var">IM.toList</span></a></span><span>
</span><span id="line-462"></span><span>
</span><span id="line-463"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#toEdges"><span class="hs-identifier hs-type">toEdges</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Edge"><span class="hs-identifier hs-type">Edge</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-464"></span><span id="toEdges"><span class="annot"><span class="annottext">toEdges :: IntMap IntSet -&gt; [(Int, Int)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#toEdges"><span class="hs-identifier hs-var hs-var">toEdges</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((Int, Path) -&gt; [(Int, Int)]) -&gt; [(Int, Path)] -&gt; [(Int, Int)]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; Path -&gt; [(Int, Int)]) -&gt; (Int, Path) -&gt; [(Int, Int)]
forall a b c. (a -&gt; b -&gt; c) -&gt; (a, b) -&gt; c
</span><a href="../../base/src/Data.Tuple.html#uncurry"><span class="hs-identifier hs-var">uncurry</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; (Int, Int)) -&gt; Path -&gt; [(Int, Int)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">((Int -&gt; (Int, Int)) -&gt; Path -&gt; [(Int, Int)])
-&gt; (Int -&gt; Int -&gt; (Int, Int)) -&gt; Int -&gt; Path -&gt; [(Int, Int)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([(Int, Path)] -&gt; [(Int, Int)])
-&gt; (IntMap IntSet -&gt; [(Int, Path)])
-&gt; IntMap IntSet
-&gt; [(Int, Int)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; [(Int, Path)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#toAdj"><span class="hs-identifier hs-var">toAdj</span></a></span><span>
</span><span id="line-465"></span><span>
</span><span id="line-466"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#predG"><span class="hs-identifier hs-type">predG</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span>
</span><span id="line-467"></span><span id="predG"><span class="annot"><span class="annottext">predG :: IntMap IntSet -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#predG"><span class="hs-identifier hs-var hs-var">predG</span></a></span></span><span> </span><span id="local-6989586621680780978"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780978"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet -&gt; IntSet)
-&gt; IntMap IntSet -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a. (a -&gt; a -&gt; a) -&gt; IntMap a -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#unionWith"><span class="hs-identifier hs-var">IM.unionWith</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#union"><span class="hs-identifier hs-var">IS.union</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet -&gt; IntMap IntSet
</span><a href="#local-6989586621680780976"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780978"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780975"><span class="hs-identifier hs-var">g0</span></a></span><span>
</span><span id="line-468"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780975"><span class="annot"><span class="annottext">g0 :: IntMap IntSet
</span><a href="#local-6989586621680780975"><span class="hs-identifier hs-var hs-var">g0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet) -&gt; IntMap IntSet -&gt; IntMap IntSet
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780978"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-469"></span><span>        </span><span class="annot"><a href="#local-6989586621680780970"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span>
</span><span id="line-470"></span><span>        </span><span id="local-6989586621680780970"><span class="annot"><span class="annottext">f :: IntMap IntSet -&gt; Int -&gt; IntSet -&gt; IntMap IntSet
</span><a href="#local-6989586621680780970"><span class="hs-identifier hs-var hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680780969"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780969"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621680780968"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780968"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621680780967"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780967"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; Int -&gt; IntMap IntSet)
-&gt; IntMap IntSet -&gt; Path -&gt; IntMap IntSet
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780965"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780965"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621680780964"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780964"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet -&gt; IntSet)
-&gt; Int -&gt; IntSet -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a. (a -&gt; a -&gt; a) -&gt; Int -&gt; a -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#insertWith"><span class="hs-identifier hs-var">IM.insertWith</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
forall a. Monoid a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Base.html#mappend"><span class="hs-identifier hs-var">mappend</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780964"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-471"></span><span>                                      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#singleton"><span class="hs-identifier hs-var">IS.singleton</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780968"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780965"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-472"></span><span>                        </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780969"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-473"></span><span>                       </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780967"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-474"></span><span>        </span><span class="annot"><a href="#local-6989586621680780976"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span>
</span><span id="line-475"></span><span>        </span><span id="local-6989586621680780976"><span class="annot"><span class="annottext">go :: IntMap IntSet -&gt; IntMap IntSet
</span><a href="#local-6989586621680780976"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((IntMap IntSet -&gt; Int -&gt; IntSet -&gt; IntMap IntSet)
 -&gt; IntMap IntSet -&gt; IntMap IntSet -&gt; IntMap IntSet)
-&gt; IntMap IntSet
-&gt; (IntMap IntSet -&gt; Int -&gt; IntSet -&gt; IntMap IntSet)
-&gt; IntMap IntSet
-&gt; IntMap IntSet
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; Int -&gt; IntSet -&gt; IntMap IntSet)
-&gt; IntMap IntSet -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a b. (a -&gt; Int -&gt; b -&gt; a) -&gt; a -&gt; IntMap b -&gt; a
</span><a href="../../containers/src/Data.IntMap.Internal.html#foldlWithKey%27"><span class="hs-identifier hs-var">IM.foldlWithKey'</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int -&gt; IntSet -&gt; IntMap IntSet
</span><a href="#local-6989586621680780970"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-476"></span><span>
</span><span id="line-477"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#pruneReach"><span class="hs-identifier hs-type">pruneReach</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span>
</span><span id="line-478"></span><span id="pruneReach"><span class="annot"><span class="annottext">pruneReach :: Rooted -&gt; Rooted
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#pruneReach"><span class="hs-identifier hs-var hs-var">pruneReach</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680780960"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780960"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780959"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780959"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780960"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780958"><span class="hs-identifier hs-var">g2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-479"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780956"><span class="annot"><span class="annottext">is :: IntSet
</span><a href="#local-6989586621680780956"><span class="hs-identifier hs-var hs-var">is</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; IntSet) -&gt; Int -&gt; IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#reachable"><span class="hs-identifier hs-var">reachable</span></a></span><span>
</span><span id="line-480"></span><span>              </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; (IntSet -&gt; IntSet) -&gt; Maybe IntSet -&gt; IntSet
forall b a. b -&gt; (a -&gt; b) -&gt; Maybe a -&gt; b
</span><a href="../../base/src/Data.Maybe.html#maybe"><span class="hs-identifier hs-var">maybe</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span>
</span><span id="line-481"></span><span>                </span><span class="annot"><span class="annottext">(Maybe IntSet -&gt; IntSet) -&gt; (Int -&gt; Maybe IntSet) -&gt; Int -&gt; IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; IntMap IntSet -&gt; Maybe IntSet)
-&gt; IntMap IntSet -&gt; Int -&gt; Maybe IntSet
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; IntMap IntSet -&gt; Maybe IntSet
forall a. Int -&gt; IntMap a -&gt; Maybe a
</span><a href="../../containers/src/Data.IntMap.Internal.html#lookup"><span class="hs-identifier hs-var">IM.lookup</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780959"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; IntSet) -&gt; Int -&gt; IntSet
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780960"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-482"></span><span>        </span><span id="local-6989586621680780958"><span class="annot"><span class="annottext">g2 :: IntMap IntSet
</span><a href="#local-6989586621680780958"><span class="hs-identifier hs-var hs-var">g2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Int, IntSet)] -&gt; IntMap IntSet
forall a. [(Int, a)] -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#fromList"><span class="hs-identifier hs-var">IM.fromList</span></a></span><span>
</span><span id="line-483"></span><span>            </span><span class="annot"><span class="annottext">([(Int, IntSet)] -&gt; IntMap IntSet)
-&gt; (IntMap IntSet -&gt; [(Int, IntSet)])
-&gt; IntMap IntSet
-&gt; IntMap IntSet
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">((Int, IntSet) -&gt; (Int, IntSet))
-&gt; [(Int, IntSet)] -&gt; [(Int, IntSet)]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet) -&gt; (Int, IntSet) -&gt; (Int, IntSet)
forall (p :: * -&gt; * -&gt; *) b c a.
Bifunctor p =&gt;
(b -&gt; c) -&gt; p a b -&gt; p a c
</span><a href="../../base/src/Data.Bifunctor.html#second"><span class="hs-identifier hs-var">second</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; Bool) -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#filter"><span class="hs-identifier hs-var">IS.filter</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntSet -&gt; Bool
</span><a href="../../containers/src/Data.IntSet.Internal.html#member"><span class="hs-operator hs-var">`IS.member`</span></a></span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780956"><span class="hs-identifier hs-var">is</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-484"></span><span>            </span><span class="annot"><span class="annottext">([(Int, IntSet)] -&gt; [(Int, IntSet)])
-&gt; (IntMap IntSet -&gt; [(Int, IntSet)])
-&gt; IntMap IntSet
-&gt; [(Int, IntSet)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">((Int, IntSet) -&gt; Bool) -&gt; [(Int, IntSet)] -&gt; [(Int, IntSet)]
forall a. (a -&gt; Bool) -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#filter"><span class="hs-identifier hs-var">filter</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntSet -&gt; Bool
</span><a href="../../containers/src/Data.IntSet.Internal.html#member"><span class="hs-operator hs-var">`IS.member`</span></a></span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780956"><span class="hs-identifier hs-var">is</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Bool) -&gt; ((Int, IntSet) -&gt; Int) -&gt; (Int, IntSet) -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, IntSet) -&gt; Int
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-485"></span><span>            </span><span class="annot"><span class="annottext">([(Int, IntSet)] -&gt; [(Int, IntSet)])
-&gt; (IntMap IntSet -&gt; [(Int, IntSet)])
-&gt; IntMap IntSet
-&gt; [(Int, IntSet)]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; [(Int, IntSet)]
forall a. IntMap a -&gt; [(Int, a)]
</span><a href="../../containers/src/Data.IntMap.Internal.html#toList"><span class="hs-identifier hs-var">IM.toList</span></a></span><span> </span><span class="annot"><span class="annottext">(IntMap IntSet -&gt; IntMap IntSet) -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780959"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-486"></span><span>
</span><span id="line-487"></span><span id="local-6989586621680781635"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#tip"><span class="hs-identifier hs-type">tip</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781635"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781635"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781635"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span></span><span>
</span><span id="line-488"></span><span id="tip"><span class="annot"><span class="annottext">tip :: forall a. Tree a -&gt; (a, [Tree a])
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#tip"><span class="hs-identifier hs-var hs-var">tip</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span id="local-6989586621680780948"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780948"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680780947"><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780947"><span class="hs-identifier hs-var">ts</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780948"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780947"><span class="hs-identifier hs-var">ts</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-489"></span><span>
</span><span id="line-490"></span><span id="local-6989586621680781633"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#parents"><span class="hs-identifier hs-type">parents</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781633"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781633"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621680781633"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span></span><span>
</span><span id="line-491"></span><span id="parents"><span class="annot"><span class="annottext">parents :: forall a. Tree a -&gt; [(a, a)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parents"><span class="hs-identifier hs-var hs-var">parents</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span id="local-6989586621680780944"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780944"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621680780943"><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780943"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; [Tree a] -&gt; [(a, a)]
forall {f :: * -&gt; *} {b} {b}.
Functor f =&gt;
b -&gt; f (Tree b) -&gt; f (b, b)
</span><a href="#local-6989586621680780942"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780944"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780943"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-492"></span><span>        </span><span class="annot"><span class="annottext">[(a, a)] -&gt; [(a, a)] -&gt; [(a, a)]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree a -&gt; [(a, a)]) -&gt; [Tree a] -&gt; [(a, a)]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="annot"><span class="annottext">Tree a -&gt; [(a, a)]
forall a. Tree a -&gt; [(a, a)]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#parents"><span class="hs-identifier hs-var">parents</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780943"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-493"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780942"><span class="annot"><span class="annottext">p :: b -&gt; f (Tree b) -&gt; f (b, b)
</span><a href="#local-6989586621680780942"><span class="hs-identifier hs-var hs-var">p</span></a></span></span><span> </span><span id="local-6989586621680780939"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780939"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Tree b -&gt; (b, b)) -&gt; f (Tree b) -&gt; f (b, b)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(b -&gt; b -&gt; (b, b)) -&gt; b -&gt; b -&gt; (b, b)
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780939"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">(b -&gt; (b, b)) -&gt; (Tree b -&gt; b) -&gt; Tree b -&gt; (b, b)
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Tree b -&gt; b
forall a. Tree a -&gt; a
</span><a href="../../containers/src/Data.Tree.html#rootLabel"><span class="hs-identifier hs-var hs-var">rootLabel</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-494"></span><span>
</span><span id="line-495"></span><span id="local-6989586621680781829"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestors"><span class="hs-identifier hs-type">ancestors</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781829"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781829"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621680781829"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span><span class="hs-special">]</span></span><span>
</span><span id="line-496"></span><span id="ancestors"><span class="annot"><span class="annottext">ancestors :: forall a. Tree a -&gt; [(a, [a])]
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#ancestors"><span class="hs-identifier hs-var hs-var">ancestors</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Tree a -&gt; [(a, [a])]
forall {b}. [b] -&gt; Tree b -&gt; [(b, [b])]
</span><a href="#local-6989586621680780937"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-497"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780937"><span class="annot"><span class="annottext">go :: [b] -&gt; Tree b -&gt; [(b, [b])]
</span><a href="#local-6989586621680780937"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680780934"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680780934"><span class="hs-identifier hs-var">acc</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span id="local-6989586621680780933"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780933"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621680780932"><span class="annot"><span class="annottext">[Tree b]
</span><a href="#local-6989586621680780932"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-498"></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680780931"><span class="annot"><span class="annottext">acc' :: [b]
</span><a href="#local-6989586621680780931"><span class="hs-identifier hs-var hs-var">acc'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780933"><span class="hs-identifier hs-var">i</span></a></span><span class="annot"><span class="annottext">b -&gt; [b] -&gt; [b]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680780934"><span class="hs-identifier hs-var">acc</span></a></span><span>
</span><span id="line-499"></span><span>            </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">[b] -&gt; [Tree b] -&gt; [(b, [b])]
forall {f :: * -&gt; *} {b} {b}.
Functor f =&gt;
b -&gt; f (Tree b) -&gt; f (b, b)
</span><a href="#local-6989586621680780930"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680780931"><span class="hs-identifier hs-var">acc'</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree b]
</span><a href="#local-6989586621680780932"><span class="hs-identifier hs-var">xs</span></a></span><span> </span><span class="annot"><span class="annottext">[(b, [b])] -&gt; [(b, [b])] -&gt; [(b, [b])]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree b -&gt; [(b, [b])]) -&gt; [Tree b] -&gt; [(b, [b])]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[b] -&gt; Tree b -&gt; [(b, [b])]
</span><a href="#local-6989586621680780937"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680780931"><span class="hs-identifier hs-var">acc'</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Tree b]
</span><a href="#local-6989586621680780932"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-500"></span><span>        </span><span id="local-6989586621680780930"><span class="annot"><span class="annottext">p :: b -&gt; f (Tree b) -&gt; f (b, b)
</span><a href="#local-6989586621680780930"><span class="hs-identifier hs-var hs-var">p</span></a></span></span><span> </span><span id="local-6989586621680780927"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780927"><span class="hs-identifier hs-var">is</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Tree b -&gt; (b, b)) -&gt; f (Tree b) -&gt; f (b, b)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(b -&gt; b -&gt; (b, b)) -&gt; b -&gt; b -&gt; (b, b)
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680780927"><span class="hs-identifier hs-var">is</span></a></span><span> </span><span class="annot"><span class="annottext">(b -&gt; (b, b)) -&gt; (Tree b -&gt; b) -&gt; Tree b -&gt; (b, b)
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Tree b -&gt; b
forall a. Tree a -&gt; a
</span><a href="../../containers/src/Data.Tree.html#rootLabel"><span class="hs-identifier hs-var hs-var">rootLabel</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-501"></span><span>
</span><span id="line-502"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#asGraph"><span class="hs-identifier hs-type">asGraph</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span>
</span><span id="line-503"></span><span id="asGraph"><span class="annot"><span class="annottext">asGraph :: Tree Int -&gt; Rooted
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#asGraph"><span class="hs-identifier hs-var hs-var">asGraph</span></a></span></span><span> </span><span id="local-6989586621680780926"><span class="annot"><span class="annottext">t :: Tree Int
</span><a href="#local-6989586621680780926"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span id="local-6989586621680780925"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780925"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><span class="annottext">[Tree Int]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680780924"><span class="annot"><span class="annottext">g :: [(Int, Path)]
</span><a href="#local-6989586621680780924"><span class="hs-identifier hs-var hs-var">g</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Tree Int -&gt; [(Int, Path)]
forall a. Tree a -&gt; [(a, [a])]
</span><a href="#local-6989586621680780923"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Tree Int
</span><a href="#local-6989586621680780926"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780925"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[(Int, Path)] -&gt; IntMap IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fromAdj"><span class="hs-identifier hs-var">fromAdj</span></a></span><span> </span><span class="annot"><span class="annottext">[(Int, Path)]
</span><a href="#local-6989586621680780924"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-504"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780923"><span class="annot"><span class="annottext">go :: Tree a -&gt; [(a, [a])]
</span><a href="#local-6989586621680780923"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span id="local-6989586621680780921"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780921"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680780920"><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780920"><span class="hs-identifier hs-var">ts</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680780918"><span class="annot"><span class="annottext">as :: [a]
</span><a href="#local-6989586621680780918"><span class="hs-keyword hs-var hs-var">as</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">([a], [[Tree a]]) -&gt; [a]
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">(([a], [[Tree a]]) -&gt; [a])
-&gt; ([Tree a] -&gt; ([a], [[Tree a]])) -&gt; [Tree a] -&gt; [a]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[(a, [Tree a])] -&gt; ([a], [[Tree a]])
forall a b. [(a, b)] -&gt; ([a], [b])
</span><a href="../../base/src/GHC.List.html#unzip"><span class="hs-identifier hs-var">unzip</span></a></span><span> </span><span class="annot"><span class="annottext">([(a, [Tree a])] -&gt; ([a], [[Tree a]]))
-&gt; ([Tree a] -&gt; [(a, [Tree a])]) -&gt; [Tree a] -&gt; ([a], [[Tree a]])
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Tree a -&gt; (a, [Tree a])) -&gt; [Tree a] -&gt; [(a, [Tree a])]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Tree a -&gt; (a, [Tree a])
forall a. Tree a -&gt; (a, [Tree a])
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#tip"><span class="hs-identifier hs-var">tip</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780920"><span class="hs-identifier hs-var">ts</span></a></span><span>
</span><span id="line-505"></span><span>                          </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780921"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680780918"><span class="hs-keyword hs-var">as</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(a, [a]) -&gt; [(a, [a])] -&gt; [(a, [a])]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span> </span><span class="annot"><span class="annottext">(Tree a -&gt; [(a, [a])]) -&gt; [Tree a] -&gt; [(a, [a])]
forall (t :: * -&gt; *) a b. Foldable t =&gt; (a -&gt; [b]) -&gt; t a -&gt; [b]
</span><a href="../../base/src/Data.Foldable.html#concatMap"><span class="hs-identifier hs-var">concatMap</span></a></span><span> </span><span class="annot"><span class="annottext">Tree a -&gt; [(a, [a])]
</span><a href="#local-6989586621680780923"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">[Tree a]
</span><a href="#local-6989586621680780920"><span class="hs-identifier hs-var">ts</span></a></span><span>
</span><span id="line-506"></span><span>
</span><span id="line-507"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#asTree"><span class="hs-identifier hs-type">asTree</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Rooted"><span class="hs-identifier hs-type">Rooted</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.Tree.html#Tree"><span class="hs-identifier hs-type">Tree</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-508"></span><span id="asTree"><span class="annot"><span class="annottext">asTree :: Rooted -&gt; Tree Int
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#asTree"><span class="hs-identifier hs-var hs-var">asTree</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680780916"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780916"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780915"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780915"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680780913"><span class="annot"><span class="annottext">go :: Int -&gt; Tree Int
</span><a href="#local-6989586621680780913"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680780912"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780912"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; [Tree Int] -&gt; Tree Int
forall a. a -&gt; [Tree a] -&gt; Tree a
</span><a href="../../containers/src/Data.Tree.html#Node"><span class="hs-identifier hs-var">Node</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780912"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int -&gt; Tree Int) -&gt; Path -&gt; [Tree Int]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Tree Int
</span><a href="#local-6989586621680780913"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; Path) -&gt; (Int -&gt; IntSet) -&gt; Int -&gt; Path
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="#local-6989586621680780911"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780912"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-509"></span><span>                   </span><span id="local-6989586621680780911"><span class="annot"><span class="annottext">f :: Int -&gt; IntSet
</span><a href="#local-6989586621680780911"><span class="hs-identifier hs-var hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780915"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet -&gt; Int -&gt; IntSet
forall a. Monoid a =&gt; IntMap a -&gt; Int -&gt; a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21"><span class="hs-operator hs-var">!</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-510"></span><span>            </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Tree Int
</span><a href="#local-6989586621680780913"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780916"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-511"></span><span>
</span><span id="line-512"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#reachable"><span class="hs-identifier hs-type">reachable</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeSet"><span class="hs-identifier hs-type">NodeSet</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeSet"><span class="hs-identifier hs-type">NodeSet</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-513"></span><span id="reachable"><span class="annot"><span class="annottext">reachable :: (Int -&gt; IntSet) -&gt; Int -&gt; IntSet
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#reachable"><span class="hs-identifier hs-var hs-var">reachable</span></a></span></span><span> </span><span id="local-6989586621680780909"><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="#local-6989586621680780909"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680780908"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780908"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; Int -&gt; IntSet
</span><a href="#local-6989586621680780907"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#singleton"><span class="hs-identifier hs-var">IS.singleton</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780908"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780908"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-514"></span><span>  </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680780907"><span class="annot"><span class="annottext">go :: IntSet -&gt; Int -&gt; IntSet
</span><a href="#local-6989586621680780907"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680780905"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780905"><span class="hs-identifier hs-var">seen</span></a></span></span><span> </span><span id="local-6989586621680780904"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780904"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680780903"><span class="annot"><span class="annottext">s :: IntSet
</span><a href="#local-6989586621680780903"><span class="hs-identifier hs-var hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IntSet
</span><a href="#local-6989586621680780909"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780904"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-515"></span><span>                        </span><span id="local-6989586621680780902"><span class="annot"><span class="annottext">as :: Path
</span><a href="#local-6989586621680780902"><span class="hs-keyword hs-var hs-var">as</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; Path
</span><a href="../../containers/src/Data.IntSet.Internal.html#toList"><span class="hs-identifier hs-var">IS.toList</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780903"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#difference"><span class="hs-operator hs-var">`IS.difference`</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780905"><span class="hs-identifier hs-var">seen</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-516"></span><span>                    </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; Int -&gt; IntSet) -&gt; IntSet -&gt; Path -&gt; IntSet
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; Int -&gt; IntSet
</span><a href="#local-6989586621680780907"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780903"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#union"><span class="hs-operator hs-var">`IS.union`</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780905"><span class="hs-identifier hs-var">seen</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Path
</span><a href="#local-6989586621680780902"><span class="hs-keyword hs-var">as</span></a></span><span>
</span><span id="line-517"></span><span>
</span><span id="line-518"></span><span id="local-6989586621680781658"><span id="local-6989586621680781659"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#collectI"><span class="hs-identifier hs-type">collectI</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781659"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781659"><span class="hs-identifier hs-type">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781659"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-519"></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781658"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781658"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781659"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621680781658"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781659"><span class="hs-identifier hs-type">c</span></a></span></span></span><span>
</span><span id="line-520"></span><span id="collectI"><span class="annot"><span class="annottext">collectI :: forall c a.
(c -&gt; c -&gt; c) -&gt; (a -&gt; Int) -&gt; (a -&gt; c) -&gt; [a] -&gt; IntMap c
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#collectI"><span class="hs-identifier hs-var hs-var">collectI</span></a></span></span><span> </span><span id="local-6989586621680780898"><span class="annot"><span class="annottext">c -&gt; c -&gt; c
</span><a href="#local-6989586621680780898"><span class="hs-operator hs-var">(&lt;&gt;)</span></a></span></span><span> </span><span id="local-6989586621680780897"><span class="annot"><span class="annottext">a -&gt; Int
</span><a href="#local-6989586621680780897"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680780896"><span class="annot"><span class="annottext">a -&gt; c
</span><a href="#local-6989586621680780896"><span class="hs-identifier hs-var">g</span></a></span></span><span>
</span><span id="line-521"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntMap c -&gt; a -&gt; IntMap c) -&gt; IntMap c -&gt; [a] -&gt; IntMap c
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780895"><span class="annot"><span class="annottext">IntMap c
</span><a href="#local-6989586621680780895"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621680780894"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780894"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(c -&gt; c -&gt; c) -&gt; Int -&gt; c -&gt; IntMap c -&gt; IntMap c
forall a. (a -&gt; a -&gt; a) -&gt; Int -&gt; a -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#insertWith"><span class="hs-identifier hs-var">IM.insertWith</span></a></span><span> </span><span class="annot"><span class="annottext">c -&gt; c -&gt; c
</span><a href="#local-6989586621680780898"><span class="hs-operator hs-var">(&lt;&gt;)</span></a></span><span>
</span><span id="line-522"></span><span>                                  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int
</span><a href="#local-6989586621680780897"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780894"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-523"></span><span>                                  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; c
</span><a href="#local-6989586621680780896"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780894"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntMap c
</span><a href="#local-6989586621680780895"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntMap c
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span>
</span><span id="line-524"></span><span>
</span><span id="line-525"></span><span class="hs-comment">-- collect :: (Ord b) =&gt; (c -&gt; c -&gt; c)</span><span>
</span><span id="line-526"></span><span class="hs-comment">--         -&gt; (a -&gt; b) -&gt; (a -&gt; c) -&gt; [a] -&gt; Map b c</span><span>
</span><span id="line-527"></span><span class="hs-comment">-- collect (&lt;&gt;) f g</span><span>
</span><span id="line-528"></span><span class="hs-comment">--   = foldl' (\m a -&gt; SM.insertWith (&lt;&gt;)</span><span>
</span><span id="line-529"></span><span class="hs-comment">--                                   (f a)</span><span>
</span><span id="line-530"></span><span class="hs-comment">--                                   (g a) m) mempty</span><span>
</span><span id="line-531"></span><span>
</span><span id="line-532"></span><span class="hs-comment">-- (renamed, old -&gt; new)</span><span>
</span><span id="line-533"></span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#renum"><span class="hs-identifier hs-type">renum</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Graph"><span class="hs-identifier hs-type">Graph</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-type">NodeMap</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-534"></span><span id="renum"><span class="annot"><span class="annottext">renum :: Int -&gt; IntMap IntSet -&gt; (IntMap IntSet, NodeMap Int)
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#renum"><span class="hs-identifier hs-var hs-var">renum</span></a></span></span><span> </span><span id="local-6989586621680780893"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780893"><span class="hs-identifier hs-var">from</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span class="hs-special">,</span><span id="local-6989586621680780892"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780892"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780891"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780891"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span class="hs-glyph">-&gt;</span><span class="hs-special">(</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780891"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780892"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-535"></span><span>  </span><span class="annot"><span class="annottext">((Int, NodeMap Int, IntMap IntSet) -&gt; (IntMap IntSet, NodeMap Int))
-&gt; (IntMap IntSet -&gt; (Int, NodeMap Int, IntMap IntSet))
-&gt; IntMap IntSet
-&gt; (IntMap IntSet, NodeMap Int)
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">((Int, NodeMap Int, IntMap IntSet)
 -&gt; Int -&gt; IntSet -&gt; (Int, NodeMap Int, IntMap IntSet))
-&gt; (Int, NodeMap Int, IntMap IntSet)
-&gt; IntMap IntSet
-&gt; (Int, NodeMap Int, IntMap IntSet)
forall a b. (a -&gt; Int -&gt; b -&gt; a) -&gt; a -&gt; IntMap b -&gt; a
</span><a href="../../containers/src/Data.IntMap.Internal.html#foldlWithKey%27"><span class="hs-identifier hs-var">IM.foldlWithKey'</span></a></span><span>
</span><span id="line-536"></span><span>      </span><span class="annot"><span class="annottext">(Int, NodeMap Int, IntMap IntSet)
-&gt; Int -&gt; IntSet -&gt; (Int, NodeMap Int, IntMap IntSet)
</span><a href="#local-6989586621680780890"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780893"><span class="hs-identifier hs-var">from</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-537"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-538"></span><span>    </span><span class="annot"><a href="#local-6989586621680780890"><span class="hs-identifier hs-type">f</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-type">NodeMap</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span>
</span><span id="line-539"></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-type">NodeMap</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../containers/src/Data.IntMap.Internal.html#IntMap"><span class="hs-identifier hs-type">IntMap</span></a></span><span> </span><span class="annot"><a href="../../containers/src/Data.IntSet.Internal.html#IntSet"><span class="hs-identifier hs-type">IntSet</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-540"></span><span>    </span><span id="local-6989586621680780890"><span class="annot"><span class="annottext">f :: (Int, NodeMap Int, IntMap IntSet)
-&gt; Int -&gt; IntSet -&gt; (Int, NodeMap Int, IntMap IntSet)
</span><a href="#local-6989586621680780890"><span class="hs-identifier hs-var hs-var">f</span></a></span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">!</span><span id="local-6989586621680780889"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780889"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">,</span><span class="hs-glyph">!</span><span id="local-6989586621680780888"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780888"><span class="hs-identifier hs-var">env</span></a></span></span><span class="hs-special">,</span><span class="hs-glyph">!</span><span id="local-6989586621680780887"><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780887"><span class="hs-identifier hs-var">new</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680780886"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780886"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621680780885"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780885"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-541"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680780884"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780884"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780883"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780883"><span class="hs-identifier hs-var">n2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780882"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780882"><span class="hs-identifier hs-var">env2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; NodeMap Int -&gt; Int -&gt; (Int, Int, NodeMap Int)
</span><a href="#local-6989586621680780881"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780889"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780888"><span class="hs-identifier hs-var">env</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780886"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-542"></span><span>                </span><span class="hs-special">(</span><span id="local-6989586621680780879"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780879"><span class="hs-identifier hs-var">n3</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780878"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780878"><span class="hs-identifier hs-var">env3</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780877"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780877"><span class="hs-identifier hs-var">ss2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; (Int, NodeMap Int, IntSet) -&gt; (Int, NodeMap Int, IntSet))
-&gt; (Int, NodeMap Int, IntSet)
-&gt; IntSet
-&gt; (Int, NodeMap Int, IntSet)
forall b. (Int -&gt; b -&gt; b) -&gt; b -&gt; IntSet -&gt; b
</span><a href="../../containers/src/Data.IntSet.Internal.html#fold"><span class="hs-identifier hs-var">IS.fold</span></a></span><span>
</span><span id="line-543"></span><span>                  </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780875"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780875"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">!</span><span id="local-6989586621680780874"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780874"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">,</span><span class="hs-glyph">!</span><span id="local-6989586621680780873"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780873"><span class="hs-identifier hs-var">env</span></a></span></span><span class="hs-special">,</span><span class="hs-glyph">!</span><span id="local-6989586621680780872"><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780872"><span class="hs-identifier hs-var">new</span></a></span></span><span class="hs-special">)</span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-544"></span><span>                      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int -&gt; NodeMap Int -&gt; Int -&gt; (Int, Int, NodeMap Int)
</span><a href="#local-6989586621680780881"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780874"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780873"><span class="hs-identifier hs-var">env</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780875"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-545"></span><span>                        </span><span class="hs-special">(</span><span id="local-6989586621680780871"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780871"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780870"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780870"><span class="hs-identifier hs-var">n2</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680780869"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780869"><span class="hs-identifier hs-var">env2</span></a></span></span><span class="hs-special">)</span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780870"><span class="hs-identifier hs-var">n2</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780869"><span class="hs-identifier hs-var">env2</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780871"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#insert"><span class="hs-operator hs-var">`IS.insert`</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780872"><span class="hs-identifier hs-var">new</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-546"></span><span>                  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780883"><span class="hs-identifier hs-var">n2</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780882"><span class="hs-identifier hs-var">env2</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntSet
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780885"><span class="hs-identifier hs-var">ss</span></a></span><span>
</span><span id="line-547"></span><span>                </span><span id="local-6989586621680780868"><span class="annot"><span class="annottext">new2 :: IntMap IntSet
</span><a href="#local-6989586621680780868"><span class="hs-identifier hs-var hs-var">new2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(IntSet -&gt; IntSet -&gt; IntSet)
-&gt; Int -&gt; IntSet -&gt; IntMap IntSet -&gt; IntMap IntSet
forall a. (a -&gt; a -&gt; a) -&gt; Int -&gt; a -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#insertWith"><span class="hs-identifier hs-var">IM.insertWith</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet -&gt; IntSet -&gt; IntSet
</span><a href="../../containers/src/Data.IntSet.Internal.html#union"><span class="hs-identifier hs-var">IS.union</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780884"><span class="hs-identifier hs-var">j</span></a></span><span> </span><span class="annot"><span class="annottext">IntSet
</span><a href="#local-6989586621680780877"><span class="hs-identifier hs-var">ss2</span></a></span><span> </span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780887"><span class="hs-identifier hs-var">new</span></a></span><span>
</span><span id="line-548"></span><span>            </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780879"><span class="hs-identifier hs-var">n3</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780878"><span class="hs-identifier hs-var">env3</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">IntMap IntSet
</span><a href="#local-6989586621680780868"><span class="hs-identifier hs-var">new2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-549"></span><span>    </span><span class="annot"><a href="#local-6989586621680780881"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-550"></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-type">NodeMap</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-551"></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span>
</span><span id="line-552"></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">,</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#NodeMap"><span class="hs-identifier hs-type">NodeMap</span></a></span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Node"><span class="hs-identifier hs-type">Node</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-553"></span><span>    </span><span id="local-6989586621680780881"><span class="annot"><span class="annottext">go :: Int -&gt; NodeMap Int -&gt; Int -&gt; (Int, Int, NodeMap Int)
</span><a href="#local-6989586621680780881"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680780867"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780867"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680780866"><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780866"><span class="hs-identifier hs-var">env</span></a></span></span><span> </span><span id="local-6989586621680780865"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780865"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-554"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int -&gt; NodeMap Int -&gt; Maybe Int
forall a. Int -&gt; IntMap a -&gt; Maybe a
</span><a href="../../containers/src/Data.IntMap.Internal.html#lookup"><span class="hs-identifier hs-var">IM.lookup</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780865"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780866"><span class="hs-identifier hs-var">env</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-555"></span><span>        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680780864"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780864"><span class="hs-identifier hs-var">j</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780864"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780867"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780866"><span class="hs-identifier hs-var">env</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-556"></span><span>        </span><span class="annot"><span class="annottext">Maybe Int
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780867"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780867"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; NodeMap Int -&gt; NodeMap Int
forall a. Int -&gt; a -&gt; IntMap a -&gt; IntMap a
</span><a href="../../containers/src/Data.IntMap.Strict.Internal.html#insert"><span class="hs-identifier hs-var">IM.insert</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780865"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780867"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">NodeMap Int
</span><a href="#local-6989586621680780866"><span class="hs-identifier hs-var">env</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-557"></span><span>
</span><span id="line-558"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-559"></span><span>
</span><span id="line-560"></span><span class="hs-keyword">newtype</span><span> </span><span id="S"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span></span><span> </span><span id="local-6989586621680781613"><span class="annot"><a href="#local-6989586621680781613"><span class="hs-identifier hs-type">z</span></a></span></span><span> </span><span id="local-6989586621680781612"><span class="annot"><a href="#local-6989586621680781612"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span id="local-6989586621680781611"><span class="annot"><a href="#local-6989586621680781611"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="S"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span></span><span> </span><span class="hs-special">{</span><span id="unS"><span class="annot"><span class="annottext">forall z s a.
S z s a -&gt; forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#unS"><span class="hs-identifier hs-var hs-var">unS</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621680781610"><span class="annot"><a href="#local-6989586621680781610"><span class="hs-identifier hs-type">o</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781611"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781612"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781613"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781610"><span class="hs-identifier hs-type">o</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781612"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781613"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781610"><span class="hs-identifier hs-type">o</span></a></span><span class="hs-special">}</span><span>
</span><span id="line-561"></span><span id="local-6989586621680781602"><span id="local-6989586621680781603"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680780858"><span class="annot"><a href="../../base/src/GHC.Base.html#Functor"><span class="hs-identifier hs-type">Functor</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781603"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781602"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-562"></span><span>  </span><span id="local-6989586621680780856"><span class="annot"><span class="annottext">fmap :: forall a b. (a -&gt; b) -&gt; S z s a -&gt; S z s b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var hs-var hs-var hs-var">fmap</span></a></span></span><span> </span><span id="local-6989586621680780855"><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621680780855"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span id="local-6989586621680780854"><span class="annot"><span class="annottext">forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780854"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (b -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s b
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780853"><span class="annot"><span class="annottext">b -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780853"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780854"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780853"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">(b -&gt; s -&gt; ST z o) -&gt; (a -&gt; b) -&gt; a -&gt; s -&gt; ST z o
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621680780855"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-563"></span><span id="local-6989586621680781768"><span id="local-6989586621680781769"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680780848"><span class="annot"><a href="../../base/src/GHC.Base.html#Monad"><span class="hs-identifier hs-type">Monad</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781769"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781768"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-564"></span><span>  </span><span id="local-6989586621680780844"><span class="annot"><span class="annottext">return :: forall a. a -&gt; S z s a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var hs-var hs-var hs-var">return</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; S z s a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span>
</span><span id="line-565"></span><span>  </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span id="local-6989586621680780843"><span class="annot"><span class="annottext">forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780843"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621680780842"><span class="annot"><span class="annottext">&gt;&gt;= :: forall a b. S z s a -&gt; (a -&gt; S z s b) -&gt; S z s b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var hs-var hs-var hs-var">&gt;&gt;=</span></a></span></span><span> </span><span id="local-6989586621680780841"><span class="annot"><span class="annottext">a -&gt; S z s b
</span><a href="#local-6989586621680780841"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (b -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s b
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780840"><span class="annot"><span class="annottext">b -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780840"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780843"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780839"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780839"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">S z s b -&gt; forall o. (b -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
forall z s a.
S z s a -&gt; forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#unS"><span class="hs-identifier hs-var hs-var">unS</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; S z s b
</span><a href="#local-6989586621680780841"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780839"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">b -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780840"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-566"></span><span id="local-6989586621680781770"><span id="local-6989586621680781771"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680780829"><span id="local-6989586621680780831"><span id="local-6989586621680780833"><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781771"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781770"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-567"></span><span>  </span><span id="local-6989586621680780827"><span class="annot"><span class="annottext">pure :: forall a. a -&gt; S z s a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var hs-var hs-var hs-var">pure</span></a></span></span><span> </span><span id="local-6989586621680780826"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780826"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780825"><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780825"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780825"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780826"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-568"></span><span>  </span><span id="local-6989586621680780823"><span class="annot"><span class="annottext">&lt;*&gt; :: forall a b. S z s (a -&gt; b) -&gt; S z s a -&gt; S z s b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">(&lt;*&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">S z s (a -&gt; b) -&gt; S z s a -&gt; S z s b
forall (m :: * -&gt; *) a b. Monad m =&gt; m (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#ap"><span class="hs-identifier hs-var">ap</span></a></span></span></span><span>
</span><span id="line-569"></span><span class="hs-comment">-- get :: S z s s</span><span>
</span><span id="line-570"></span><span class="hs-comment">-- get = S (\k s -&gt; k s s)</span><span>
</span><span id="line-571"></span><span id="local-6989586621680781761"><span id="local-6989586621680781762"><span id="local-6989586621680781763"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-type">gets</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781763"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781762"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781761"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781763"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781762"><span class="hs-identifier hs-type">a</span></a></span></span></span></span><span>
</span><span id="line-572"></span><span id="gets"><span class="annot"><span class="annottext">gets :: forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var hs-var">gets</span></a></span></span><span> </span><span id="local-6989586621680780821"><span class="annot"><span class="annottext">s -&gt; a
</span><a href="#local-6989586621680780821"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780820"><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780820"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span id="local-6989586621680780819"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621680780819"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780820"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">s -&gt; a
</span><a href="#local-6989586621680780821"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621680780819"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621680780819"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-573"></span><span class="hs-comment">-- set :: s -&gt; S z s ()</span><span>
</span><span id="line-574"></span><span class="hs-comment">-- set s = S (\k _ -&gt; k () s)</span><span>
</span><span id="line-575"></span><span id="local-6989586621680781747"><span id="local-6989586621680781748"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#modify"><span class="hs-identifier hs-type">modify</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781748"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781748"><span class="hs-identifier hs-type">s</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781747"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781748"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-576"></span><span id="modify"><span class="annot"><span class="annottext">modify :: forall s z. (s -&gt; s) -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#modify"><span class="hs-identifier hs-var hs-var">modify</span></a></span></span><span> </span><span id="local-6989586621680780818"><span class="annot"><span class="annottext">s -&gt; s
</span><a href="#local-6989586621680780818"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (() -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s ()
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780817"><span class="annot"><span class="annottext">() -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780817"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">() -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780817"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(s -&gt; ST z o) -&gt; (s -&gt; s) -&gt; s -&gt; ST z o
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; s
</span><a href="#local-6989586621680780818"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-577"></span><span class="hs-comment">-- runS :: S z s a -&gt; s -&gt; ST z (a, s)</span><span>
</span><span id="line-578"></span><span class="hs-comment">-- runS (S g) = g (\a s -&gt; return (a,s))</span><span>
</span><span id="line-579"></span><span id="local-6989586621680781808"><span id="local-6989586621680781809"><span id="local-6989586621680781810"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#evalS"><span class="hs-identifier hs-type">evalS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781810"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781809"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781808"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781809"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781810"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781808"><span class="hs-identifier hs-type">a</span></a></span></span></span></span><span>
</span><span id="line-580"></span><span id="evalS"><span class="annot"><span class="annottext">evalS :: forall z s a. S z s a -&gt; s -&gt; ST z a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#evalS"><span class="hs-identifier hs-var hs-var">evalS</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span id="local-6989586621680780815"><span class="annot"><span class="annottext">forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780815"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; s -&gt; ST z a) -&gt; s -&gt; ST z a
forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780815"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; ST z a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; ST z a) -&gt; (s -&gt; a) -&gt; s -&gt; ST z a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((s -&gt; a) -&gt; s -&gt; ST z a) -&gt; (a -&gt; s -&gt; a) -&gt; a -&gt; s -&gt; ST z a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; s -&gt; a
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-581"></span><span class="hs-comment">-- execS :: S z s a -&gt; s -&gt; ST z s</span><span>
</span><span id="line-582"></span><span class="hs-comment">-- execS (S g) = g ((return .) . flip const)</span><span>
</span><span id="line-583"></span><span id="local-6989586621680781718"><span id="local-6989586621680781719"><span id="local-6989586621680781720"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-type">st</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781720"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781719"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781720"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781718"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781719"><span class="hs-identifier hs-type">a</span></a></span></span></span></span><span>
</span><span id="line-584"></span><span id="st"><span class="annot"><span class="annottext">st :: forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var hs-var">st</span></a></span></span><span> </span><span id="local-6989586621680780814"><span class="annot"><span class="annottext">ST z a
</span><a href="#local-6989586621680780814"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
forall z s a.
(forall o. (a -&gt; s -&gt; ST z o) -&gt; s -&gt; ST z o) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-var">S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680780812"><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780812"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span id="local-6989586621680780811"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621680780811"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-585"></span><span>  </span><span id="local-6989586621680780810"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780810"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ST z a
</span><a href="#local-6989586621680780814"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-586"></span><span>  </span><span class="annot"><span class="annottext">a -&gt; s -&gt; ST z o
</span><a href="#local-6989586621680780812"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780810"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621680780811"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-587"></span><span id="local-6989586621680781749"><span id="local-6989586621680781750"><span id="local-6989586621680781751"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-type">store</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781751"><span class="hs-identifier hs-type">z</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781750"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781751"><span class="hs-identifier hs-type">z</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-588"></span><span>      </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781749"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781751"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781750"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680781750"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781751"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781749"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-589"></span><span id="store"><span class="annot"><span class="annottext">store :: forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; a -&gt; S z s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#store"><span class="hs-identifier hs-var hs-var">store</span></a></span></span><span> </span><span id="local-6989586621680780806"><span class="annot"><span class="annottext">s -&gt; Arr z a
</span><a href="#local-6989586621680780806"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680780805"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780805"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621680780804"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780804"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-590"></span><span>  </span><span id="local-6989586621680780803"><span class="annot"><span class="annottext">Arr z a
</span><a href="#local-6989586621680780803"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(s -&gt; Arr z a) -&gt; S z s (Arr z a)
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; Arr z a
</span><a href="#local-6989586621680780806"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-591"></span><span>  </span><span class="annot"><span class="annottext">ST z () -&gt; S z s ()
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr z a
</span><a href="#local-6989586621680780803"><span class="hs-identifier hs-var">a</span></a></span><span class="annot"><span class="annottext">Arr z a -&gt; a -&gt; Int -&gt; ST z ()
forall s a. MArray (A s) a (ST s) =&gt; Arr s a -&gt; a -&gt; Int -&gt; ST s ()
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#.%3D"><span class="hs-operator hs-var">.=</span></a></span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680780804"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780805"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-592"></span><span id="local-6989586621680781703"><span id="local-6989586621680781704"><span id="local-6989586621680781705"><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-type">fetch</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../array/src/Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#A"><span class="hs-identifier hs-type">A</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781705"><span class="hs-identifier hs-type">z</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><a href="#local-6989586621680781704"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.ST.html#ST"><span class="hs-identifier hs-type">ST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781705"><span class="hs-identifier hs-type">z</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-593"></span><span>      </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680781703"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#Arr"><span class="hs-identifier hs-type">Arr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781705"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781704"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.CmmToAsm.CFG.Dominators.html#S"><span class="hs-identifier hs-type">S</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781705"><span class="hs-identifier hs-type">z</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781703"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680781704"><span class="hs-identifier hs-type">a</span></a></span></span></span></span><span>
</span><span id="line-594"></span><span id="fetch"><span class="annot"><span class="annottext">fetch :: forall z a s.
MArray (A z) a (ST z) =&gt;
(s -&gt; Arr z a) -&gt; Int -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#fetch"><span class="hs-identifier hs-var hs-var">fetch</span></a></span></span><span> </span><span id="local-6989586621680780799"><span class="annot"><span class="annottext">s -&gt; Arr z a
</span><a href="#local-6989586621680780799"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680780798"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780798"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-595"></span><span>  </span><span id="local-6989586621680780797"><span class="annot"><span class="annottext">Arr z a
</span><a href="#local-6989586621680780797"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(s -&gt; Arr z a) -&gt; S z s (Arr z a)
forall s a z. (s -&gt; a) -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#gets"><span class="hs-identifier hs-var">gets</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; Arr z a
</span><a href="#local-6989586621680780799"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-596"></span><span>  </span><span class="annot"><span class="annottext">ST z a -&gt; S z s a
forall z a s. ST z a -&gt; S z s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#st"><span class="hs-identifier hs-var">st</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Arr z a
</span><a href="#local-6989586621680780797"><span class="hs-identifier hs-var">a</span></a></span><span class="annot"><span class="annottext">Arr z a -&gt; Int -&gt; ST z a
forall s a. MArray (A s) a (ST s) =&gt; A s Int a -&gt; Int -&gt; ST s a
</span><a href="GHC.CmmToAsm.CFG.Dominators.html#%21%3A"><span class="hs-operator hs-var">!:</span></a></span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680780798"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-597"></span><span>
</span><span id="line-598"></span></pre></body></html>